Class D is derived from class B The class D does not contain any data members of its own Does the class D require constructors?

Answer 1

Yes, D requires constructors, because all classes require constructors. However, whether you need to actually define them or not depends on whether B has any constructors other than a default constructor and a copy constructor. To understand why all classes must have constructors you need to understand how the compiler-generated constructors work.

All classes must have at least two constructors, one of which must be a copy constructor. If you do not define any constructors at all, the compiler automatically generates a default constructor (with no parameters) and a copy constructor. If you define any constructor, the compiler only generates the copy constructor unless you define your own. The compiler also generates an assignment operator and a destructor unless you provide your own.

In many cases the compiler-generated constructors will be sufficient for your needs thus there is no need to define your own in these cases. However, if your class contains one or more pointers to memory that is exclusive to each instance of a class (not shared amongst them), then you must provide your own constructors, as well as an assignment operator and a destructor, in order to manage that memory correctly. This is because the compiler-generated versions will treat all pointers as being pointers to shared memory and will simply copy their addresses, not what they contain. You must override this behaviour and ensure that those pointers are deep-copied; copying the memory itself, not just the address.

Constructors exist in order to initialise member variables. Even if your class has no member variables and therefore no real need for constructors, the compiler-generated constructors will still exist, as will the assignment operator and destructor, and it is important that you fully understand how these constructors work so that you will know exactly when you need to define your own and when you do not.

Consider the following example:

#include <iostream>

class B {

public:

B():m_data(0){ std::cout << "B::B()" << std::endl; }

B(const B& b):m_data(b.m_data){ std::cout << "B::B(const B&)" << std::endl; }

B& operator= (const B& b){ m_data = b.m_data; std::cout << "B::operator= (const B&)" << std::endl; return( *this ); }

virtual ~B(){ std::cout << "B::~B()" << std::endl; }

void SetData(const int i){m_data=i; std::cout << "B::m_data=" << m_data << std::endl; }

int GetData(){return m_data;}

private:

int m_data;

};

class D: public B {}; // no members or constructors defined.

int main()

{

D d1; // default constructor

std::cout << "d1.GetData()==" << d1.GetData() << std::endl;

d1.SetData( 100 );

std::cout << "d1.GetData()==" << d1.GetData() << std::endl;

D d2(d1); // copy constructor -- same as: D d2 = *d;

std::cout << "d2.GetData()==" << d2.GetData() << std::endl;

d1.SetData( 200 );

std::cout << "d1.GetData()==" << d1.GetData() << std::endl;

std::cout << "d2.GetData()==" << d2.GetData() << std::endl;

d2 = d1; // assignment operator

std::cout << "d2.GetData()==" << d2.GetData() << std::endl;

std::cout << std::endl;

return(0);

} // All objects fall from scope here.

Output:

B::B()

d1.GetData()==0

B::m_data=100

d1.GetData()==100

B::B(const B&)

d2.GetData()==100

B::m_data=200

d1.GetData()==200

d2.GetData()==100

B::operator= (const B&)

d2.GetData()==200

B::~B()

B::~B()

Since we provided no constructors in D it is difficult to see exactly what is going on here. In the main function we initially declare d1 to be of type D, but the first line of output is B::B(). Clearly the base class constructor is being invoked but it is not clear exactly how it was invoked. You'd be forgiven for thinking that since D inherits from B then it must inherit B's default constructor, but you cannot inherit constructors any more than you can inherit friends, operators or destructors from a base class. They are part of the interface but they are not part of the inheritable interface.

The answer, of course, lies in the fact the compiler has generated constructors for us Behind the Scenes. But since we don't have access to them we cannot trace them. So let's just clarify exactly what's going on by explicitly declaring constructors exactly as the compiler would have generated them for us. Let's also include some trace code so that we can see how they relate to the existing traces:

class D: public B {

public:

D():B(){ std::cout << "D::D()" << std::endl; }

D(const D& d):B(d){ std::cout << "D::D(const D&)" << std::endl; }

D& operator= (const D& d){ B::operator=( d ); std::cout << "D::operator= (const D&)" << std::endl; return( *this ); }

~D(){ std::cout << "D::~D()" << std::endl; }

};

Output:

B::B()

D::D()

d1.GetData()==0

B::m_data=100

d1.GetData()==100

B::B(const B&)

D::D(const D&)

d2.GetData()==100

B::m_data=200

d1.GetData()==200

d2.GetData()==100

B::operator= (const B&)

D::operator= (const D&)

d2.GetData()==200

D::~D()

B::~B()

D::~D()

B::~B()

Now things are somewhat clearer. Although B::B() looks like it was invoked before D::D(), they were actually invoked the other way around. Here's the default constructor for D:

D():B(){ std::cout << "D::D()" << std::endl; }

Note that before we enter the construction body (which contains the trace) we explicitly call the default constructor of B, hence it appears to be invoked first. However, this is, in fact, the correct order of events since we cannot construct an instance of D unless we first construct an instance of B. Only when B has been fully constructed can we then construct D.

Note also that even if we'd omitted the call to B() in the initialisation list, it would have been invoked automatically for us. That is, if we do not specify a base class constructor, the default constructor is invoked automatically. This fact is vital when it comes to declaring copy constructors:

D(const D& d):B(d){ std::cout << "D::D(const D&)" << std::endl; }

Here, we've called the base class copy constructor from the initialisation list: B(d). We have to do this because if we omit it, we'll end up calling the default constructor instead, which is not what we expect of a copy constructor. Here's the output trace snippet we'd have encountered had we omitted it:

d1.GetData()==100

B::B()

D::D(const D&)

d2.GetData()==0

Clearly, d2 cannot be a copy of d1 if their base class members differ, hence we must explicitly call the base class copy constructor (just as the compiler-generated copy constructor did).

Note that the assignment operator is not a constructor (it applies to existing objects only) and therefore does not have an initialisation list. However, the function body invokes the base class method, just as the compiler-generated version did.

The remainder of the output is fairly self-explanatory but note that destruction occurs in the reverse order of construction, thus D must be destroyed before B can be destroyed. Note also that since D is derived from B, B's constructor must be declared virtual. This is required because if we held a pointer to a derived class' base class and subsequently destroyed it, we would rightly expect the derived class' constructor to be invoked first. But if B's constructor were not virtual, we would end up destroying B alone, leaving an invalid instance of D in memory with no way to destroy it (a memory leak).

Answer 2

All classes require constructors. Even if you declare none, the compiler will automatically generate a default constructor (which invokes the base class default constructor) and a copy constructor (which invokes the base class copy constructor). But if you define any constructor, you lose the default constructor (the copy constructor is always generated).

In this particular case the compiler-generated constructors may suffice, in which case you need not define your own. However, if the base class has other constructors besides a default and copy constructor, you may wish to add similar constructors to your derived class in order to make use of them.

Another cavaet is that if either or both the default and copy constructors of the base class have been defined but are not implemented (disabled), you must also disable them in the derived class, as well as provide user-defined constructors that match the base class constructors.

Remember that you invoke specific base class constructors via the derived class constructor initialisation list, as follows:

class base

{

public:

base(): m_data(0) {}

base( const base& rhs ) : m_data(0) {}

virtual ~base() {}

base& operator= ( const base& rhs ) { m_data=rhs.m_data; return( *this ); }

private:

int m_data;

};

class derived : public base

{

public:

derived(): base() {}

derived( const derived& rhs ) : base( rhs ) {}

};

Note also that unless you define your own, a destructor and a default assignement operator are also generated by the compiler. However, the base class destructor must be declared virtual to ensure correct tear-down. The compiler-generated destructor of a base class is always declared non-virtual. In the above example, there is no need to declare either a destructor nor an assignement operator in the derived class, since the compiler-generated versions will behave accordingly.

Answer 3

Am not sure what it is you are actually asking. Class D inherits all the protected and public members of class B. It doesn't need any data members of its own, but in order to be of any use it must override one or more of the virtual methods declared in class B, otherwise there's not much point in deriving from class B.