C++ Defaulted Function

​

Syntax

class Widget {
public:
    // Inline defaulting
    Widget() = default; 
    
    // Declaration for out-of-line defaulting
    Widget(const Widget& other); 
};

// Out-of-line defaulting
Widget::Widget(const Widget& other) = default;

​

Applicability

• Default constructor: ClassName()
• Copy constructor: ClassName(const ClassName&)
• Move constructor: ClassName(ClassName&&)
• Copy assignment operator: ClassName& operator=(const ClassName&)
• Move assignment operator: ClassName& operator=(ClassName&&)
• Destructor: ~ClassName()
• C++20 and later: The three-way comparison operator (operator<=>) and all secondary comparison operators (operator==, operator!=, operator<, operator>, operator<=, operator>=).

​

Technical Mechanics and Rules

1. An explicitly defaulted copy constructor or copy assignment operator is permitted to take a non-const reference (T&) even if the implicitly generated version would require a const reference (const T&).
2. Since C++14 (via CWG 1753), the return type of a defaulted assignment operator is allowed to differ from the implicit declaration (e.g., returning void or returning by value instead of T&).

• Exception Specification Mismatch (Inline): If a function is explicitly defaulted on its first declaration but has an exception specification that is incompatible with the implicitly generated one, the function is defined as deleted (= delete). This rule has applied since C++11.
• Signature Mismatch (Inline): If the signature deviates in other incompatible ways (such as an invalid parameter type), the program is ill-formed in C++11, C++14, and C++17. In C++20 and later, the function is instead defined as deleted.
• Out-of-Line Mismatch: If the function is explicitly defaulted out-of-line (after its initial declaration) and possesses any mismatch in signature or exception specification, the program is ill-formed and will fail to compile.

class SignatureRules {
public:
    // Valid: The standard explicitly allows non-const references for copy operations
    SignatureRules(SignatureRules& other) = default; 

    // Valid (Since C++14): Assignment operators can return void instead of T&
    void operator=(const SignatureRules&) = default; 
};

struct ThrowingMember {
    ThrowingMember() noexcept(false) {}
};

class InlineMismatch {
    ThrowingMember member;
public:
    // C++11 and later: Defined as deleted because the explicit 'noexcept' 
    // conflicts with the implicitly generated 'noexcept(false)'
    InlineMismatch() noexcept = default; 
};

class NonConstructible {
protected:
    NonConstructible() = default; // Compiler generates it, but it is protected
};

• If a special member function is defaulted on its first declaration (inline within the class body), the function is considered trivial (provided all base classes and members also have trivial corresponding operations).
• If the function is defaulted out-of-line (after its initial declaration), it is considered non-trivial, which can affect how the object is allocated, copied, or passed through ABIs.

class ReferenceHolder {
    int& ref;
public:
    // Implicitly becomes deleted because 'ref' cannot be default-initialized
    ReferenceHolder() = default; 
};