C++11 virtual destructors and auto generation of move special functions

by

  1. No, a defaulted destructor is still considered user defined, so it will prevent the generation of move operations. Also declare the move operations default-ed to make the compiler generate them.

  2. You need to only declare the move operations as default-ed in the base class. In the derived class, the destructor won’t be user defined anymore (unless you explicitly say so), so the move operations won’t be deleted.

So what I’d do is the following:

class Base
{
    virtual ~Base() = default;
    Base(Base&&) = default;
    Base& operator=(Base&&) = default;
    // probably need to think about copy operations also, as the move disables them
    Base(const Base&) = default;
    Base& operator=(const Base&) = default;
};

I highly recommend this talk by the person who contributed probably the most to the move semantics: http://www.slideshare.net/ripplelabs/howard-hinnant-accu2014

Or, if you can get your hands on, you should read the Item 17: Understand special member function generation from Scott Meyers’ excellent book Effective Modern C++. This issue is excellently explained.

PS: I think you should think a bit more about your base classes. Most of the time, you should use abstract classes, so there will be no need to copy/move instances of them.

PSS: I think by default destructors are marked noexcept in C++11/14, so not explicitly specifying it shouldn’t cause any problems:

Inheriting constructors and the implicitly-declared default
constructors, copy constructors, move constructors, destructors,
copy-assignment operators, move-assignment operators are all
noexcept(true) by default, unless they are required to call a function
that is noexcept(false), in which case these functions are
noexcept(false).

More Related Contents:

  1. What is move semantics?
  2. push_back vs emplace_back
  3. How to enforce move semantics when a vector grows?
  4. What is std::move(), and when should it be used?
  5. What can I do with a moved-from object?
  6. Can I list-initialize a vector of move-only type?
  7. Reusing a moved container?
  8. Why no default move-assignment/move-constructor?
  9. What constitutes a valid state for a “moved from” object in C++11?
  10. Move assignment operator and `if (this != &rhs)`
  11. What are the rules for automatic generation of move operations?
  12. C++11 move constructor not called, default constructor preferred
  13. Why does std::move prevent RVO (return value optimization)?
  14. Is the pass-by-value-and-then-move construct a bad idiom?
  15. How does std::move() transfer values into RValues?
  16. Does moving leave the object in a usable state?
  17. Copy constructor is not inherited
  18. Is it possible to std::move objects out of functions? (C++11)
  19. Why do some people use swap for move assignments?
  20. Non-copyable elements in vector
  21. Initializer-list-constructing a vector of noncopyable (but movable) objects
  22. Can I typically/always use std::forward instead of std::move?
  23. Is a `=default` move constructor equivalent to a member-wise move constructor?
  24. Is an object guaranteed to be moved when it is returned?
  25. Move or Named Return Value Optimization (NRVO)?
  26. What’s the point of a final virtual function?
  27. Using C++ base class constructors?
  28. Should all/most setter functions in C++11 be written as function templates accepting universal references?
  29. Move semantics == custom swap function obsolete?
  30. Move constructor on derived object

Leave a Comment