Are move constructors/assignment operators generated for derived classes

Question

If class X is derived from class Y and class Y has any of:

A user-declared copy constructor,
A user-declared copy assignment operator,
A user-declared destructor
A user-declared move constructor,
A user-declared move assignment operator,

Will a move constructor and move assignment operator be implicitly defaulted for class X providing it declares none of the above?

e.g.

struct Y
{
     virtual ~Y() {}

     // .... stuff

};

struct X : public Y
{
   // ... stuff but no destructor, 
   //               no copy/move assignment operator 
   //               no copy/move constructor

   // will X have a default move constructor / assignment operator?
};

I am currently using gcc, but I am mainly interested in what the correct behaviour should be (as opposed to whether or not a particular compiler is standards compliant)..

Unrelated to your matter, but just in case you're not aware of it with C++11 you can now do virtual ~Y() = default; rather than define the destructor yourself (although perhaps your compiler doesn't support it yet). — Luc Danton
@Luc Danton Out of interest, if I was to use virtual ~Y() = default; will that trigger the compiler to implicitly default the move constructor / assignment operator? or would I need to explicitly default these operations? — mark
@mark - no it will not, because explicitly defaulted destructor is a user-defined destructor. — Gene Bushuyev

Matthieu M. Matthieu M. · Accepted Answer · 2012-05-22T10:51:49

As far as the derived class is concerned, the fact that an attribute or a base class has user-defined or implicit special functions does not matter. All that matter is their presence.

Compliant C++11 compilers should automatically provide the move constructors and assignment operators for the struct and class, if possible (which is clearly defined in the Standard), even though only classes with dynamically allocated buffers will really benefit from it (moving an int is just copying it).

Therefore, if your class embeds a std::string or a std::unique_ptr (for example), then its move constructor will call the embedded string or unique_ptr move constructor and it will be efficient... for free.

Simply changing the compilation mode should thus slightly improve performance.

Are move constructors/assignment operators generated for derived classes

2 Answers