Constructor confusion

I always think I know C++ pretty well, but sometimes I'm surprised by even the most fundamental things.

In the following scenario, I'm confused as to why the constructor Deri开发者_Go百科ved::Derived(const Base&) is invoked:

class Base
{ };

class Derived : public Base
{
    public:

    Derived() { }

    Derived(const Base& b) 
    {
        std::cout << "Called Derived::Derived(const Base& b)" << std::endl;
    }
};

int main()
{
    Derived d;
    Base b;
    d = b;
}

This outputs: Called Derived::Derived(const Base& b), indicating that the second constructor in Derived was invoked. Now, I thought I knew C++ pretty well, but I can't figure out why that constructor would be invoked. I understand the whole "rule of four" concept, and I would think that the expression d = b would do one of two things: Either it would 1) invoke the implicit (compiler-generated) assignment operator of Base, or 2) Trigger a compiler error complaining that the function Derived& operator = (const Base&) does not exist.

Instead, it called a constructor, even though the expression d = b is an assignment expression.

So why does this happen?

d = b can happen because b is converted to Derived. The second constructor is used for automatic type conversion. It's like d = (Derived) b

Derived isa Base, but Base isn'ta Derived, so it has to be converted before assignment.

assigning base to derived? perhaps you meant (a) by ref (b) or derived to base. This doesn't really make sense, but the compiler is correctly using your (non-explicit) constructor to convert the Base instance to a new Derived instance (which is subsequently assigned into d).

Use an explicut constructor to prevent this from happening automatically.

Personally I think you messed up your code sample, because, normally assigning firstclass base to derived makes no sense without a conversion

There are two interacting features at play here:

• Assignment Operators are never inherited
• A constructor that is not explicit, or a conversion operator (operator T()) define a user-conversion that can be used implicitly as part of a conversion sequence

Assignement Operators are never inherited

A simple code example:

struct Base {}; // implicitly declares operator=(Base const&);
struct Derived: Base {}; // implicitly declares operator=(Derived const&);

int main() {
  Derived d;
  Base b;
  d = b; // fails
}

From ideone:

prog.cpp: In function ‘int main()’:
prog.cpp:7: error: no match for ‘operator=’ in ‘d = b’
prog.cpp:2: note: candidates are: Derived& Derived::operator=(const Derived&)

Conversion sequence

Whenever there is an "impedance" mismatch, such as here:

• Derived::operator= expects a Derived const& argument
• a Base& is provided

the compiler will try to establish a conversion sequence to bridge the gap. Such a conversion sequence may contain at most one user-defined conversion.

Here, it will look for:

• any constructor of Derived that can be invoked with a Base& (not explicit)
• a conversion operator in Base that would yield a Derived item

There is no Base::operator Derived() but there is a Derived::Derived(Base const&) constructor.

Therefore our conversion sequence is defined for us:

• Base&
• Base const& (trivial)
• Derived (using Derived::Derived(Base const&))
• Derived const& (temporary object bound to a const reference)

And then Derived::operator(Derived const&) is called.

In action

If we augment the code with some more traces, we can see it in action.

#include <iostream>

struct Base {}; // implicitly declares Base& operator(Base const&);
struct Derived: Base {
  Derived() {}
  Derived(Base const&) { std::cout << "Derived::Derived(Base const&)\n"; }
  Derived& operator=(Derived const&) {
    std::cout << "Derived::operator=(Derived const&)\n";
    return *this;
  }
};

int main() {
  Derived d;
  Base b;
  d = b;
}

Which outputs:

Derived::Derived(Base const&)
Derived::operator=(Derived const&)

Note: Preventing this ?

It is possible, in C++, to remove a constructor for being used in conversion sequences. To do so, one need to prefix the declaration of the constructor using the explicit keyword.

In C++0x, it becomes possible to use this keyword on conversion operators (operator T()) as well.

If here we use explicit before Derived::Derived(Base const&) then the code becomes ill-formed and should be rejected by the compiler.

Since you've defined a constructor for Derived which takes type Base and you are down-casting Base, the compiler chooses the most suitable constructor for the upcast, which in this case is the Dervied(const Base& b) you've defined. If you did not define this constructor you would actually get a compiling error when trying to make the assignment. For more info, you can read the following at Linuxtopia.

It can't assign value of different type, so it should first construct a Derived temporary.