Is a `=default` move constructor equivalent to a member-wise move constructor?

by

Yes both are the same.

But

struct Example { 
    string a, b; 

    Example(Example&& mE)            = default;
    Example& operator=(Example&& mE) = default;
}

This version will permits you to skip the body definition.

However, you have to follow some rules when you declare explicitly-defaulted-functions :

8.4.2 Explicitly-defaulted functions [dcl.fct.def.default]

A function definition of the form:

  attribute-specifier-seqopt decl-specifier-seqopt declarator virt-specifier-seqopt = default ;

is called an explicitly-defaulted definition. A function that is explicitly defaulted shall

  • be a special member function,

  • have the same declared function type (except for possibly differing ref-qualifiers and except that in the case of a copy constructor or copy assignment operator, the parameter type may be “reference to non-const T”, where T is the name of the member function’s class) as if it had been implicitly declared,

  • not have default arguments.

More Related Contents:

  1. What is move semantics?
  2. push_back vs emplace_back
  3. What is std::move(), and when should it be used?
  4. What can I do with a moved-from object?
  5. Can I list-initialize a vector of move-only type?
  6. How do I use a custom deleter with a std::unique_ptr member?
  7. Why no default move-assignment/move-constructor?
  8. What constitutes a valid state for a “moved from” object in C++11?
  9. What are the rules for automatic generation of move operations?
  10. Why is `std::move` named `std::move`?
  11. C++11 move constructor not called, default constructor preferred
  12. Is the pass-by-value-and-then-move construct a bad idiom?
  13. Move-only version of std::function
  14. How does std::move() transfer values into RValues?
  15. Do I really need to implement user-provided constructor for const objects?
  16. Is it possible to std::move objects out of functions? (C++11)
  17. Why do some people use swap for move assignments?
  18. Non-copyable elements in vector
  19. Can I typically/always use std::forward instead of std::move?
  20. copy vs std::move for ints
  21. Move or Named Return Value Optimization (NRVO)?
  22. C++11 anonymous union with non-trivial members
  23. Should the Copy-and-Swap Idiom become the Copy-and-Move Idiom in C++11?
  24. Why the initializer of std::function has to be CopyConstructible?
  25. Why would I std::move an std::shared_ptr?
  26. Default member values best practice
  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. What is use of the ref-qualifier `const &&`?

Leave a Comment