C.ctor

C.ctor: Constructors, assignments, and destructors

These functions control the lifecycle of objects: creation, copy, move, and destruction. Define constructors to guarantee and simplify initialization of classes.

These are default operations:

• a default constructor: X()
• a copy constructor: X(const X&)
• a copy assignment: operator=(const X&)
• a move constructor: X(X&&)
• a move assignment: operator=(X&&)
• a destructor: ~X()

By default, the compiler defines each of these operations if it is used, but the default can be suppressed.

The default operations are a set of related operations that together implement the lifecycle semantics of an object. By default, C++ treats classes as value-like types, but not all types are value-like.

Set of default operations rules:

• C.20: If you can avoid defining any default operations, do
• C.21: If you define or =delete any copy, move, or destructor function, define or =delete them all
• C.22: Make default operations consistent

Destructor rules:

• C.30: Define a destructor if a class needs an explicit action at object destruction
• C.31: All resources acquired by a class must be released by the class's destructor
• C.32: If a class has a raw pointer (T*) or reference (T&), consider whether it might be owning
• C.33: If a class has an owning pointer member, define a destructor
• C.35: A base class destructor should be either public and virtual, or protected and non-virtual
• C.36: A destructor must not fail
• C.37: Make destructors noexcept

Constructor rules:

• C.40: Define a constructor if a class has an invariant
• C.41: A constructor should create a fully initialized object
• C.42: If a constructor cannot construct a valid object, throw an exception
• C.43: Ensure that a copyable class has a default constructor
• C.44: Prefer default constructors to be simple and non-throwing
• C.45: Don't define a default constructor that only initializes data members; use member initializers instead
• C.46: By default, declare single-argument constructors explicit
• C.47: Define and initialize member variables in the order of member declaration
• C.48: Prefer in-class initializers to member initializers in constructors for constant initializers
• C.49: Prefer initialization to assignment in constructors
• C.50: Use a factory function if you need "virtual behavior" during initialization
• C.51: Use delegating constructors to represent common actions for all constructors of a class
• C.52: Use inheriting constructors to import constructors into a derived class that does not need further explicit initialization

Copy and move rules:

• C.60: Make copy assignment non-virtual, take the parameter by const&, and return by non-const&
• C.61: A copy operation should copy
• C.62: Make copy assignment safe for self-assignment
• C.63: Make move assignment non-virtual, take the parameter by &&, and return by non-const&
• C.64: A move operation should move and leave its source in a valid state
• C.65: Make move assignment safe for self-assignment
• C.66: Make move operations noexcept
• C.67: A polymorphic class should suppress public copy/move

Other default operations rules:

• C.80: Use =default if you have to be explicit about using the default semantics
• C.81: Use =delete when you want to disable default behavior (without wanting an alternative)
• C.82: Don't call virtual functions in constructors and destructors
• C.83: For value-like types, consider providing a noexcept swap function
• C.84: A swap must not fail
• C.85: Make swap noexcept
• C.86: Make == symmetric with respect of operand types and noexcept
• C.87: Beware of == on base classes
• C.89: Make a hash noexcept
• C.90: Rely on constructors and assignment operators, not memset and memcpy