C++ operator = overload inherited, is it necessary to redefine in the derived class though defined in the base class?

Question

Say I have this C++ code:

class Base {
public:
 Base& operator=(const Base&);
};

class Derivate : public Base {
public:

};

And say I have a main where

Derivate d1;
//Something on d1
Derivate d2 = d1;

In this situation would the operator = of the base class called? I have some code that basically does such thing, but debugging with gdb I don't see any call to such operator.

Is it necessary in this case redifine the operator in the derivate class?

The compiler is quite happy to implicitly generate one for you. But it's up to you to make sure it has correct semantics. — StoryTeller - Unslander Monica, Nov 14 '16 at 19:52
So it wouldn't use the inherithed one from the base class, right? Is it the same thing for a copy constructor? — user8469759, Nov 14 '16 at 19:54
The reason why your `Base::operator=` isn't being called is that `Derivate d2 = d1;` uses the copy constructor, not the assignment operator. — Brian Bi, Nov 14 '16 at 19:56
It would. The implicitly generated one calls the assignment operator on all base classes and members. The same is true for the copy c'tor. But again, if you have pointers & such in your classes, it will likely not be the behavior you want by default. — StoryTeller - Unslander Monica, Nov 14 '16 at 19:56
`type name = something` is always construction and never assignment. — NathanOliver, Nov 14 '16 at 20:00

Raindrop7 · Answer 1 · 2016-11-14T20:41:34.590

no in fact you are calling copy constructor because you are assigning d1 to d2 while constructing d2 thus assignment operator is not called here:

#include <iostream>
using namespace std;

class Base 
{
    public:
        Base& operator = (const Base&);
};

Base& Base::operator = (const Base&)
{
    cout << "assignment operator" << endl;
    // implementation here
    return *this;
}

class Derivate : public Base
{
    public:
        Derivate(){}
        Derivate(const Derivate& rhs){cout << "copy constructor" << endl;}
};

int main()
{
    Derivate d1;
    //Something on d1
    Derivate d2 = d1; // copy constructor not assignment operstor
    //Derivate d2(d1); // is the same as above calling cpy ctor
    d2 = d1; // here assignment operator is called

    return 0;
}

why d2 = d1; calls the base assignment operator?

because if you don't provide a derived class assignment operator the compiler will define one for you as follows:

Derivate& operator = (const Base& rhs); // not Derivate

so this Derived one calls as you guess the base's assignment operator as long as passing a const reference instead of derived one.

assignment operator is really inherited:

make it private scoped in base class and see the result.

The automatically declared assignment operator is `Derivate& operator=(const Derivate&);`, not `Derivate& operator=(const Base&);`. — aschepler, Nov 14 '16 at 20:45
@aschepler yes I know I said the compiler adds implicitly `Derivate& operator=(const Base&);` which in turn invokes the base one — Raindrop7, Nov 14 '16 at 20:46

C++ operator = overload inherited, is it necessary to redefine in the derived class though defined in the base class?

1 Answers1