Move Constructors without noexcept

#include <string>
#include <iostream>

class Person {
  private:
    std::string name;
  public:
    Person(const char* n)
     : name{n} {
    }

    std::string getName() const {
      return name;
    }

    // print out when we copy or move:
    Person(const Person& p)
     : name{p.name} {
        std::cout << "COPY " << name << '\n';
    }
    Person(Person&& p)
     : name{std::move(p.name)} {
        std::cout << "MOVE " << name << '\n';
    }
    //...
};

int main()
{
   std::vector<Person> coll{ "Wolfgang Amadeus Mozart",
                             "Johann Sebastian Bach",
                             "Ludwig van Beethoven" };
                             
   std::cout << "capacity: " << coll.capacity() << '\n';
   
   coll.push_back("Pjotr Iljitsch Tschaikowski");
}

The output of the program is as follows:

COPY Wolfgang Amadeus Mozart
COPY Johann Sebastian Bach
COPY Ludwig van Beethoven
capacity: 3
MOVE Pjotr Iljitsch Tschaikowski
COPY Wolfgang Amadeus Mozart
COPY Johann Sebastian Bach
COPY Ludwig van Beethoven

The following diagrams demonstrate how does push_back() work internally:

• Step 1:
• Step 2:
• Step 3:

The reason that vector reallocation does not use move semantics is the strong exception handling guarantee we give for push_back(): When an exception is thrown in the middle of the reallocation of the vector the C++ standard library guarantees to roll back the vector to its previous state. Please see STL container with noexcept for more details.

Move Constructors with noexcept

When we guarantee that the move constructor never throw:

Person(Person&& p) noexcept
     : name{std::move(p.name)} {
        std::cout << "MOVE " << name << '\n';
    }

The output will be:

COPY Wolfgang Amadeus Mozart
COPY Johann Sebastian Bach
COPY Ludwig van Beethoven
capacity: 3
MOVE Pjotr Iljitsch Tschaikowski
MOVE Wolfgang Amadeus Mozart
MOVE Johann Sebastian Bach
MOVE Ludwig van Beethoven

• Step 1:
• Step 2:
• Step 3:

Please see emplace_back vs. push_back for more details.

Details of noexcept Declarations

• See noexcept specifier.
• The move constructor usually does not output anything; therefore, in general when members do not throw, we can give the guarantee not to throw for the move constructor as a whole.
• If you implement a move constructor, you should declare whether and when it guarantees not to throw.
• If you do not have to implement the move constructor, you do not have to specify anything at all.

noexcept for Copying and Moving Special Member Functions

• noexcept condition is generated for generated special member functions.
• noexcept condition is not generated for user-implement special member functions.
• Before C++20, if the generated and specified noexcept conditions contradict, the defined function was deleted. Since C++20, the specified noexcept condition takes precedence over the generated one.

   class C
   {
      public:
       // guarantees not to throw (OK since C++20)
      C(const C&) noexcept = default;
        
      // specifies that it might throw (OK since C++20)
      C(C&&) noexcept(false) = default;
   };
  

noexcept for Destructors

By rule, destructors always guarantee not to throw by default. This applies to both generated and implemented destructors. For example:

class B
{
private:
   std::string s;
public:
   ~B() {
       // automatically always declared as ~B() noexcept
   }
};

With noexcept(false), you can declare them without this guarantee, but that usually never makes any sense because several guarantees of the C++ standard library are based on the fact that destructors never throw.

noexcept Declarations in Class Hierarchies

• Following the rules of the C++ standard, we should declare it not to throw when all base classes and all member types do not throw on a move construction. The general pattern would be as follows:

   class Ancestor {
   ...
   };
     
   class Descendant : public Ancestor {
      MemType member;
      Descendant(Descendant&&)
      noexcept(std::is_nothrow_move_constructible_v<Ancestor> &&
               std::is_nothrow_move_constructible_v<MemType>);
   };
  

• The move assignment operator might use the same pattern but note that the move assignment operator should be deleted in polymorphic types anyway, which means that there is usually no need to implement them in derived classes.
• Note that the type trait std::is_nothrow_move_constructible<> always yields false because it also checks whether you can create an object of this type with the move constructor, which is not possible for abstract types.
• The solution is to implement a non-abstract wrapper:

  #include <iostream>
  #include <vector>
  #include <type_traits>
    
  template<typename Base>
  struct Wrapper : Base {
     using Base::Base;
     // implement all possibly wrapped pure virtual functions:
     // --> Make Wrapper is not an abstract class
     void print() const {}
  };
    
  template<typename T>
  static constexpr inline bool is_nothrow_movable_v
  = std::is_nothrow_move_constructible_v<Wrapper<T>>;
    
    
  class Base {
  private:
     std::string id;
  public:
     Base() = default;
     // pure virtual function (forces abstract base class)
     virtual void print() const = 0;
     virtual ~Base() = default;
    
  protected:
     // protected copy and move semantics (also forces abstract base class):
     Base(const Base&) = default;
     Base(Base&&) = default;
     // disable assignment operator (due to the problem of slicing):
     Base& operator= (Base&&) = delete;
     Base& operator= (const Base&) = delete;
  };
    
  class Drv : public Base {
  public:
     void print() const override {
        std::cout << "Drv::print()\n";
     }
    
     Drv() = default;
     Drv(const Drv& rhs)
     {
        if (this == &rhs) return;
        std::cout << "COPY\n";
     }
    
     Drv(Drv&& rhs) noexcept(is_nothrow_movable_v<Base>)
     //Drv(Drv&& rhs) noexcept(std::is_nothrow_move_constructible_v<Base>)
     {
        if (this == &rhs) return;
        std::cout << "MOVE\n";
    
     }
    
  };
    
  int main()
  {
     std::cout << std::boolalpha;
     std::cout << "std::is_nothrow_move_constructible_v<Base>: "
     << std::is_nothrow_move_constructible_v<Base> << '\n';
    
     std::cout << "is_nothrow_movable_v<Base>                : "
     << is_nothrow_movable_v<Base> << '\n';
    
     std::vector<Drv> v;
     v.reserve(2);
    
     v.push_back(Drv{});
     v.push_back(Drv{});
     v.push_back(Drv{});
  }
  

  • Using is_no_throw_movable_v in Drv’s move constructor yields:

    MOVE
    MOVE
    MOVE
    MOVE
    MOVE
    

  • Using std::is_nothrow_move_constructible_v in Drv’s move constructor yields:

     MOVE
     MOVE
     MOVE
     COPY
     COPY