Question

I’m trying to understand this behaviour but it seems I don’t. Please see this code:

#include <iostream>
using namespace std;

class Base
{
public:
    void operator=(const Base& rf)
    {
        cout << "base operator=" << endl;
        this->y = rf.y;
    }
    int y;
    Base() : y(100) { }
};

class Derived : public Base
{
public:
    int x;
    Derived() : x(100) { }
};

int main()
{
    Derived test;
    Derived test2;
    test2.x = 0;
    test2.y = 0;
    test.operator=(test2); // operator auto-generated for derived class but...
    cout << test.x << endl << test.y << endl;
    cin.ignore();
    return 0;
}

PROGRAM OUTPUT:

> base operator=
>  0
>  0

Now where I’m confused is:
The rule says that a derived class never inherits the assigment operator, instead it creates its own operator= however in this example base’s operator= gets invoked on the derived class.

Second I was able to explicitly invoke an assigment operator on a derived class, which isn’t in turn explicitly defined in the derived class.

Now if I understand it correctly, this means that any user defined base’s operator always gets invoked on the derived class?

Answer 1

The generated ones automatically call the base-class assignment operator.

// generated version looks basically like this
Derived& operator=(Derived const& other){
  Base::operator=(static_cast<Base const&>(other));
  x = other.x;
  return *this;
}

The cast is there to avoid an accidential call to a templated Base::operator= like this one:

template<class Other>
Base& operator=(Other const& other); // accepts everything

Or a strange one like this:

// forward-declare 'Derived' outside of 'Base'
Base& operator=(Derived const& other); // accepts derived class (for whatever reason)

---

Second I was able to explicitly invoke an assigment operator on a derived class, which isn’t in turn explicitly defined in the derived class.

The compiler automatically declares an assignment operator if you do not and your class allows it (i.e., no reference members and some other arcane rules) and additionally defines it if you actually use it somewhere.