Default copyable derived classes

Question

Suppose I have a silly class hierarchy.

class Base {
public:
    Base() = default;
    virtual ~Base() = default;
    virtual void print() = 0;
};

class Derived : public Base {
public:
    Derived() {
        stuff.resize(1000);
    }
    void print() override {
        cout << "Whatever\n";
    }
private:
    std::vector<int> stuff;
};

And I want to use it like this:

void printIt(Base* b) {
    b->print();
}

int main() {

    Derived d1;
    Derived d2 = d1;

    printIt(&d1);
    printIt(&d2);
}

This compiles and works fine, but Clang warns me:

warning: definition of implicit copy constructor for 'Base' is deprecated because it has a user-declared destructor

That seems fine and correct - if people copy Base bad things will happen so I'll delete the copy constructor.

class Base {
public:
    Base() = default;
    virtual ~Base() = default;
    virtual void print() = 0;

    Base(const Base&) = delete;
    Base& operator=(const Base&) = delete;
};

However then I get this error:

main.cpp:38:17: error: call to implicitly-deleted copy constructor of 'Derived'
        Derived d2 = d1;
                ^    ~~
main.cpp:18:21: note: copy constructor of 'Derived' is implicitly deleted because base class 'Base' has a deleted copy
      constructor
    class Derived : public Base {
                    ^
main.cpp:14:9: note: 'Base' has been explicitly marked deleted here
        Base(const Base&) = delete;
        ^

Ok... fair enough. What if I try to add it back in explicitly?

class Derived : public Base {
public:
    Derived() {
        stuff.resize(1000);
    }
    void print() override {
        cout << "Whatever\n";
    }

    Derived(const Derived&) = default;

private:
    std::vector<int> stuff;
};

Then:

main.cpp:40:17: error: call to implicitly-deleted copy constructor of 'Derived'
        Derived d2 = d1;
                ^    ~~
main.cpp:27:9: note: explicitly defaulted function was implicitly deleted here
        Derived(const Derived&) = default;
        ^
main.cpp:18:21: note: copy constructor of 'Derived' is implicitly deleted because base class 'Base' has a deleted copy
      constructor
    class Derived : public Base {
                    ^
main.cpp:14:9: note: 'Base' has been explicitly marked deleted here
        Base(const Base&) = delete;
        ^

No joy, which also kind of makes sense. What is the solution here? Should I just ignore the original warning? Maybe I should add Base(Base&) etc as protected?

I do not know a lot about this, but maybe removing the `virtual ~Base() = default;` is what you need. Your original warning tells you that the implicit copy constructor of `Base` is deprecated **because** it has a user declared destructor (note the emphasis in because). — apalomer, Jan 04 '18 at 11:19
The warning is due to [this](https://stackoverflow.com/questions/26687426). Best not to ignore it in new code. — StoryTeller - Unslander Monica, Jan 04 '18 at 11:20
@StoryTeller: Why is it best to ignore it? The reason for adding it seems sensible at least. — Timmmm, Jan 04 '18 at 11:23
@Timmmm - Your example doesn't seem to be inline with that requirement. You don't delete polymorphically. And I said it's best **not** to ignore the warning. — StoryTeller - Unslander Monica, Jan 04 '18 at 11:24
@StoryTeller Oh sorry I misread. And I don't delete it polymorphically in this example but I do in my code. Generally good idea to have all virtual classes support polymorphic deletion. — Timmmm, Jan 04 '18 at 11:25
@Timmmm - I suppose so. The general advice of either a public virtual d'tor or a protected non-virtual one will result in the exact same warning either way. — StoryTeller - Unslander Monica, Jan 04 '18 at 11:28
Btw, what options did you give Clang? I'm playing with your example now and I'm not getting the warning. — StoryTeller - Unslander Monica, Jan 04 '18 at 11:33

score 1 · Answer 1 · answered Jan 04 '18 at 11:24

So it does compile without warnings if I make the copy/assignment protected. This seems like a reasonable solution:

class Base {
public:
    Base() = default;
    virtual ~Base() = default;
    virtual void print() = 0;

protected:        
    Base(const Base&) = default;
    Base& operator=(const Base&) = default;
};

class Derived : public Base {
public:
    Derived() {
        stuff.resize(1000);
    }
    void print() override {
        cout << "Whatever\n";
    }

private:
    std::vector<int> stuff;
};

void printIt(Base* b) {
    b->print();
}

int main() {

    Derived d1;
    Derived d2 = d1;

    printIt(&d1);
    printIt(&d2);
}

user7860670 · Answer 2 · 2018-01-04T11:33:11.130

0

If you want to use it like Derived d2 = d1; you will need to do 3 things:

1) make Base copy (and move) constructors and assignment operators protected and not deleted to delegate capability to allow/prohibit copy/move to derived class

protected: Base(const Base&) = default;
protected: Base& operator=(const Base&) = default;

2) make Derived copy (and move) constructors and assignment operators public to indicate that copy/move is allowed

public: Derived(const Derived&) = default;
public: Derived& operator=(Derived&) = default;

3) mark Derived as final to prevent accidental slicing when someone decides to derive from it again

class Derived final: public Base

edited Jan 04 '18 at 11:33

answered Jan 04 '18 at 11:25

user7860670

35,849
4
58
84

It seems you don't actually need to declare `Derived`'s copy/assignment functions as public - I guess the implicitly generated ones are always public. And I guess by "splicing" you meant object slicing? Good point about final to prevent that. – Timmmm Jan 04 '18 at 11:28
Can you explain how does changing the constructors to protected is any different than in public? Both its children objects do know of the Base's constructor existence and 2 Base objects are created similarly in Public. – Jan 04 '18 at 11:46
It means you can't do something like: `void foo(Base* a, Base* b) { *a = *b; }` ... I think. – Timmmm Jan 04 '18 at 11:49
@AlisherKassymov If constructor is `public` then anywhere in the program there could be some code performing `Base` to `Base` copy / move. Note that even though you define default `Base` constructor as `public` in reality is actually also `protected` because `Base` class is abstract. So you may want to change all the `Base` constructors to be `protected` for to make things more explicit. – user7860670 Jan 04 '18 at 11:55
@Timmmm There is indeed no need to do so, however it is always a good idea to make things explicit. – user7860670 Jan 04 '18 at 11:57
@VTT Ok, so if you make a parent class constructor protected, you can access it only if you create a Derived object am I right? So Protected is accessible only to its child class. Also, if you inherit the Base (Parent) in a protected way, there is no way to initiate a Base object of type Base, as only Derived has an access to it. – Jan 04 '18 at 13:47

Default copyable derived classes

2 Answers2