Question

I have a question about C++, how to assign a Base object to a Derived object? or how to assign a pointer to a Base object to a pointer to a Derived object?

In the code below, the two lines are wrong. How to correct that?

#include <iostream>
using namespace std;
class A{
public:
   int a;
};

class B:public A{
public:
   int b;
};

int main(){
    A a;
    B b;
    b = a; //what happend?
    cout << b.b << endl;   

    B* b2;
    b2 = &a;        // what happened?
    cout << b->b << endl;
}

Answer 1

When an object is on the stack, you can only really assign objects of the same type to one another. They can be converted through overloaded cast operators or overloaded assignment operators, but you’re specifying a conversion at that point. The compiler can’t do such conversions itself.

A a;
B b;
b = a;

In this case, you’re trying to assigning an A to a B, but A isn’t a B, so it doesn’t work.

A a;
B b;
a = b;

This does work, after a fashion, but it probably won’t be what you expect. You just sliced your B. B is an A, so the assignment can take place, but because it’s on the stack, it’s just going to assign the parts of b which are part of A to a. So, what you get is an A. It’s not a B in spite of the fact that you assigned from a B.

If you really want to be assigning objects of one type to another, they need to be pointers.

A* pa = NULL;
B* pb = new B;
pa = pb;

This works. pa now points to pb, so it’s still a B. If you have virtual functions on A and B overrides them, then when you call them on pa, they’ll call the B version (non-virtual ones will still call the A version).

A* pa = new A;
B* pb = pa;

This doesn’t work. pa doesn’t point B, so you can’t assign it to pb which must point to a B. Just because a B is an A doesn’t mean than an A is a B.

A a;
B* pb = &a;

This doesn’t work for the same reason as the previous one. It just so happens that the A is on the stack this time instead of the heap.

A* pa;
B b;
pa = &b;

This does work. b is a B which is an A, so A can point to it. Virtual functions will call the B versions and non-virtual ones will call the A versions.

So, basically, A* can point to B’s because B is an A. B* can’t point to A because it isn’t a B.