Question

I just want to find an answer to this question

Let A be a parent class with B,C the child classes.

Now we create objects as follows,

1. A o1 = new A();
2. B o2 = new B();

3. C o3 = new C();

4. A o4 = new B();

5. B o5 = new A();
6. C o6 = new B();

From these which will all create errors and why.. I got confused a lot because from 6 we know that it is an error because b may have some specialized variables and 7 is possible and 8 is not possible.

If i’m wrong please correct me and also,

1. A o7 = o4;
2. B 08 = o5;

Kindly suggest me the right answers and with explanations and also give me links for tutorials with this kind of puzzles.

Answer 1

Assuming all objects are of pointer types-

1. A *o1 = new A();   // Correct
2. B *o2 = new B();   // Correct
3. C *o3 = new C();   // Correct

4. A *o4 = new B(); // A pointer to a derived class is type-compatible with a pointer to its base class. This is up casting which acts by default.
5. B *o5 = new A(); // Wrong because the other-wise relationship of the above comment isn't true. Though there is a separate concept called Down-casting which isn't valid here.
6. C *o6 = new B();  // Wrong : C, B has no hierarchial relationships

7. A *o7 = o4;      // Correct because o4, o7 are both of same type
8. B *o8 = o5;      // Wrong. Since, 5 itself is wrong.

Explanation for 4 & 5:

1. new B() calls A's constructor followed by B's constructor. So, we have sub-objects of type A*,B*. Since, there is a sub-object of type A*, the lvalue can point to it which is also equal to of type A*. This is helpful to access base class overridden virtual methods in derived class.

2. new A() constructs an object of type A* and returns it’s address. So, return type is of A* but the receiving type is of B*. So, they both are incompatible and is wrong.

Example: Output results

#include <iostream>
using namespace std;
class A
{
    public:
    A(){
        cout << " \n Constructor A \n";
    }
    virtual ~A(){
        cout << "\n Destructor A \n";
    }
};

class B: public A
{
    public:
    B(){
        cout << " \n Constructor B \n";
    }
    ~B(){
        cout << "\n Destructor B \n";
    }

};

class C: public A
{
    public:
    C(){
        cout << " \n Constructor C \n";
    }
    ~C(){
        cout << "\n Destructor C \n";
    }

};

int main()
{
    A* obj1 = new A;
    std::cout<< "******************************" << std::endl;

    A* obj2 = new B;
    std::cout<< "******************************" << std::endl;

    A* obj3 = new C;
    std::cout<< "******************************" << std::endl;

    delete obj1;
    std::cout<< "******************************" << std::endl;

    delete obj2;
    std::cout<< "******************************" << std::endl;

    delete obj3;
    std::cout<< "******************************" << std::endl;

    return 0;
}

Results:

Constructor A

---

Constructor A

Constructor B

---

Constructor A

Constructor C

---

Destructor A

---

Destructor B

Destructor A

---

Destructor C

Destructor A

---

Notice that the order of destruction is reverse to the order of construction.