CODEWITHSUNDEEP
c++c++11constructordefault
DarioP
DarioP

Reputation: 5465

Why default move ctor and assignment are no more added by compiler when a destructor is defined?

I cannot understand the rationale behind the automatic addition of default ctors. In particular I find very awkward that every single time I just need to add an empty virtual destructor and nothing more, I loose the move stuffs, but adding them I loose the copy and default things, so I end up adding all this chunk of code:

virtual ~SomeClass(){}           // you are the guilty!
//virtual ~SomeClass() = default // would be the same

SomeClass(SomeClass&&) = default;                 // no more auto-added
SomeClass& operator=(SomeClass&&) = default;      // no more auto-added
SomeClass(const SomeClass&) = default;            // but with the moves defined,
SomeClass& operator=(const SomeClass&) = default; // I'm now missing the copy
SomeClass(){}                                     // and the default as well

I'm sure there is a reason for making my classes ugly and letting me desire an evil macro, I just would like to know it to feel more comfortable.

Upvotes: 6

Views: 174

Answers (2)

Mike Seymour
Mike Seymour

Reputation: 254631

The problem is that your class is trying to do two separate things: providing a polymorphic interface (hence the need for the virtual destructor) and managing concrete data members (hence the need for the copy/move operations). It's generally a good idea to give each class a single responsibility.

I'd move the virtual destructor, and any virtual function declarations, to an empty, abstract base class. Then any concrete class(es) deriving from that will be free to autogenerate all the needful things.

Example:

#include <iostream>

struct Movable {
    Movable() {}
    Movable(Movable&&m) {std::cout << "Moving\n";}
};

struct SomeInterface {
    virtual ~SomeInterface() {}

    // no data members, so no need for any other special member functions
};

struct SomeClass : SomeInterface {
    Movable stuff;

    // no user-declared special functions, so all are auto-generated
};

int main() {
    SomeClass c;
    SomeClass c2(std::move(c));  // uses the auto-generated move constructor
}

Upvotes: 0

triple_r
triple_r

Reputation: 1047

Take a look at this. It explains something called the rule of five, which is essentially what standard requires.

Generally, for most cases, compiler creates defaults for copy constructor, copy assignment, move assignment, and destructor. But, if a programmer defines any of these, then the compiler assumes the user has encapsulated something in this class that requires his/her special, let's say. destructor. Now that the programmer knows that he/she is going to need a destructor, the compiler will know that the programmer know what's going on and just not create the defaults for the rest (because, based on the assumption that the compiler makes, the default ones are going to be wrong, and can even result in undesired behavior).

Upvotes: 1

Related Questions