Why is my derived class constructor deleted?

Question

In the following my compiler says that my derived class constructor cannot be found:

    struct Drink
    {
        Drink(const Drink& other);
    };

    struct PepsiMax : Drink {};

    int main()
    {
        PepsiMax myPepsi;         // <--- the default constructor of PepsiMax cannot be referenced, it is a deleted function
    }

I know the default constructor of Drink needs to be defined, because I created a copy constructor and the compiler won't make a default constructor for me. However the error message says that it can't find the default constructor for my PepsiMax class, which I expected it to generate. If I define the default constructor for PepsiMax, it then shows an error saying that it can't find the Drink default constructor, which is what I expect.

Can I assume that it's referring to the default constructor of 'Drink' and not 'PepsiMax', or am I misunderstanding something? I expected the compiler to create a default constructor for 'PepsiMax' which calls the base class constructor immediately as the first thing it does.

Edit: My confusion is cleared up, thanks for your help. My explanation about my naive interpretation of the compiler-generated constructor is in an answer.

Answer 1

The fix is to write

struct Drink
{
    Drink() = default;
    Drink(const Drink& other);
};

The presence of the copy constructor obviates the automatic generation of the default constructor (as you know). But this also means that the compiler cannot generate the default constructor for PepsiMax on which PepsiMax myPepsi; is relying. You need to re-introduce it.

Answer 2

When you try to create a variable of PepsiMax type, the default constructor of that class should be called. Since it has a base class (Drink), that default constructor will call Drink's default constructor as well. Now in your Drink class you have declared your own copy constructor. That prevents the compiler from automatically generating a default constructor, thus it can not be called, thus a default constructor for PepsiMax can not be generated as well.

To prevent that, you should explicitly tell the compiler to generate a default constructor with

Drink() = default;

or implement your own default constructor for Drink.

Answer 3

Cppreference quotes that

The implicitly-declared or defaulted default constructor for class T is undefined if: T has a direct or virtual base which has a deleted default constructor, or it is ambiguous or inaccessible from this constructor.

In your example, implicit default constructor of class Drink is deleted because of the presence of the copy constructor.

Subsequently, the implicitly-declared or defaulted default constructor for class PepsiMax is undefined considering its direct base class Drink has a deleted default constructor.

Answer 4

I just want to add to the answers others have made. I understand now, and just want to explain my confusion.

struct Base
{
    Base(const Base& other);       // <---- My copy constructor, putting this here prevents the compiler generating a default and empty constructor
};

Derived : Base
{
    // Nothing here. The compiler should generate a default constructor here
    // Something like Derived() : Base::Base() {}
}

Now, there are two ways to think about how the compiler goes about this for a naive person (me). The way I was thinking is that the compiler does the equivalent of pasting the default constructor in place, and then compiling. If this is what it actually did, then error message should be the same as if I pasted that line in manually, which is actually a different error, that it can't find the Base default constructor, not the Derived default constructor.

However, what 'obviously' happens is that the compiler tries to generates the:

Derived() : Base::Base(){}

Parses it, fails to find Base::Base(), and doesn't generate that line at all, and then complains that it can't find the Derived default constructor. This was obvious for those who answered. The confusion here was about 'how' the compiler exactly generates the default constructor. Thanks for enlightening me just that little bit extra.