Base class 'class A' should be explicitly initialized in the copy constructor [duplicate]

Question

I confused by compiler warning. I used MinGW 5.3.0 32bit and i try to compile this code:

#include <QCoreApplication>
#include <QObject>
#include <QDebug>    

class A : public QObject
    {
        Q_OBJECT

    public:
        A(QObject* parent = 0){ Q_UNUSED(parent);}
        ~A() {qDebug()<<"~A()";}

        virtual void func(){}
    private:

    };

    class B : public A
    {
        Q_OBJECT

        public:
            B(){}
            B (const B & object) {/*do somthing*/}
            ~B(){}

            void func(){/*do somthing*/}
    private:

    };

    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);

        return a.exec();
    }

My compiler tell me:

In copy constructor 'B::B(const B&)': WARNING: base class 'class A' should be explicitly initialized in the copy constructor [-Wextra] B (const B & object) {/do somthing/} ^

Whats wrong?

Answer 1

For a hand-rolled copy constructor (i.e. your B::B(const B &)) it is unusual (although not technically illegal in standard C++) in practice to rely on the default constructor of A being invoked - which is what will happen if you implement the copy constructor of B without explicitly initialising the A in the initialiser list of B constructor.

Your compiler is configured to warn about such things. That is a quality-of-implementation concern for compilers (they are not required to issue warnings in cases like this). But, practically, your compile vendor is doing you a favour.

Your copy constructor of B

B (const B & object) {/*do somthing*/}

is actually equivalent to

B (const B & object) : A() {/*do somthing*/}

which, as I said above, is unusual to explicitly do in practice - it is rarely a desirable behaviour.

The way to shut your compiler up, so it doesn't issue this warning, is to explicitly construct A in the initialiser list of Bs constructor. You could do it like the above using the default constructor of A (which, theoretically, may or may not stop the compiler complaining), but the more usual technique is something akin to

B (const B & object) : A(object) {/*do somthing*/}

Bear in mind that the copy constructor of A will be invoked before the body of B constructors (i.e. base classes are constructed first).

Even better, you would be better off not defining a copy constructor at all, if possible. In that case (assuming something doesn't prevent it from doing so, such as a private copy constructor of a base class) the compiler will automatically generate a copy constructor for B that initialises all its base classes using their copy constructors (recursively) and all its data members.

Answer 2

The problem here is that your class B inherits from A that itself inherits from QObject class which is not designed to be copyable.

Therefore you cannot call the QObject copy constructor in your class A copy constructor provided you have implemented one.

You can still call the default constructor from A in B copy ctor B (const B & object) : A() or even B (const B & object) : A(object) but it will never construct an exact copy of your object.

See http://doc.qt.io/qt-5/object.html#identity-vs-value for more detailed explanation of Qt's choice.