C++11 move constructor not called, default constructor preferred

by

What you are seeing is copy elision, which allows the compiler to directly construct a temporary into a target it is to be copied/moved into and thus elide a copy (or move) constructor/destructor pair. The situations in which the compiler is allowed to apply copy elision are specified in §12.8.32 of the C++11 standard:

When certain criteria are met, an implementation is allowed to omit
the copy/move construction of a class object, even if the copy/move
constructor and/or destructor for the object have side effects. In such
cases, the implementation treats the source and target of the omitted
copy/move operation as simply two different ways of referring to the
same object, and the destruction of that object occurs at the later of
the times when the two objects would have been destroyed without the
optimization. This elision of copy/move
operations, called copy elision, is permitted in the following
circumstances (which maybe combined to eliminate multiple copies):

  • in a return statement in a function with a class return type, when the expression is the name of a non-volatile automatic object with
    the same cv-unqualified type as the function return type, the
    copy/move operation can be omitted by constructing the automatic
    object directly into the function’s return value
  • in a throw-expression, when the operand is the name of a non-volatile automatic object whose scope does not extend beyond
    the end of the innermost enclosing try-block (if there is one), the
    copy/move operation from the operand to the exception object (15.1)
    can be omitted by constructing the automatic object directly into
    the exception object
  • when a temporary class object that has not been bound to a reference (12.2) would be copied/moved to a class object with he
    same cv-unqualified type, the copy/move operation can be omitted by
    constructing the temporary object directly into the target of the
    omitted copy/move
  • when the exception-declaration of an exception handler (Clause 15) declares an object of the same type (except for cv-qualification) as
    the exception object (15.1), the copy/move operation can be omitted
    bytreatingthe exception-declaration as an alias for the exception
    object if the meaning of the program will be unchanged except for the
    execution of constructors and destructors for the object declared by
    the exception-declaration.

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. How do I use a custom deleter with a std::unique_ptr member?
  8. Reusing a moved container?
  9. Why no default move-assignment/move-constructor?
  10. What constitutes a valid state for a “moved from” object in C++11?
  11. Move assignment operator and `if (this != &rhs)`
  12. What are the rules for automatic generation of move operations?
  13. Why is `std::move` named `std::move`?
  14. Is the pass-by-value-and-then-move construct a bad idiom?
  15. Move-only version of std::function
  16. How does std::move() transfer values into RValues?
  17. Is it possible to std::move objects out of functions? (C++11)
  18. Why do some people use swap for move assignments?
  19. Non-copyable elements in vector
  20. Can I typically/always use std::forward instead of std::move?
  21. Is a `=default` move constructor equivalent to a member-wise move constructor?
  22. copy vs std::move for ints
  23. Do built-in types have move semantics?
  24. Move or Named Return Value Optimization (NRVO)?
  25. Is std::array movable?
  26. Should the Copy-and-Swap Idiom become the Copy-and-Move Idiom in C++11?
  27. Why would I std::move an std::shared_ptr?
  28. C++: std::move with rvalue reference is not moving contents
  29. What is std::move(), and when should it be used and does it actually move anything?
  30. What is use of the ref-qualifier `const &&`?

Leave a Comment