Special member functions

Special member functions in C++ are functions which the compiler will automatically generate if they are used, but not declared explicitly by the programmer. The automatically generated special member functions are:

• Default constructor if no other constructor is explicitly declared.
• Copy constructor if no move constructor and move assignment operator are explicitly declared.

If a destructor is declared generation of a copy constructor is deprecated (C++11, proposal N3242 ).

• Move constructor if no copy constructor, copy assignment operator, move assignment operator and destructor are explicitly declared.
• Copy assignment operator if no move constructor and move assignment operator are explicitly declared.

If a destructor is declared, generation of a copy assignment operator is deprecated.

• Move assignment operator if no copy constructor, copy assignment operator, move constructor and destructor are explicitly declared.
• Destructor

In these cases the compiler generated versions of these functions perform a memberwise operation. For example the compiler generated destructor will destroy each sub-object (base class or member) of the object.

The compiler generated functions will be public, non-virtual and the copy constructor and assignment operators will receive const& parameters (and not be of the alternative legal forms).

Example

The following example depicts two classes: Explicit for which all special member functions are explicitly declared and Implicit for which none are declared.

#include <iostream>
#include <string>

class Explicit
{
public:
    Explicit()
    {
        std::cout << "Default constructor " << msg << '\n';
    }

    Explicit(const std::string& value)
        : msg(value)
    {
        std::cout << "Non-default constructor " << msg << '\n';
    }

    Explicit(const Explicit& other)
    {
        std::cout << "Copy constructor " << msg << '\n';
        *this = other; // invoke copy assignment operator
    }

    Explicit& operator=(const Explicit& other)
    {
        std::cout << "Copy assignment operator " << msg << '\n';
        if (this != &other) {
            msg = other.msg;
        }
        return *this;
    }

    Explicit(Explicit&& other) noexcept
    {
        std::cout << "Move constructor " << msg << '\n';
        *this = std::move(other); // invoke move assignment operator
    }

    Explicit& operator=(Explicit&& other) noexcept
    {
        std::cout << "Move assignment operator " << msg << '\n';
        if (this != &other) {
            msg = std::move(other.msg);
        }
        return *this;
    }

    ~Explicit()
    {
        std::cout << "Destructor " << msg << '\n';
    }

private:
    friend class Implicit;
    std::string msg;
};

class Implicit : public Explicit
{
public:
    void Spew()
    {
        std::cout << "Implicit(" << msg << ", " << member.msg << ")\n";
    }

private:
    Explicit member;
};

Signatures

Here are the signatures of the special member functions:

Function	syntax for class MyClass
Default constructor	MyClass();
Copy constructor	MyClass(const MyClass& other);
Move constructor	MyClass(MyClass&& other) noexcept;
Copy assignment operator	MyClass& operator=(const MyClass& other);
Move assignment operator	MyClass& operator=(MyClass&& other) noexcept;
Destructor	~MyClass() noexcept;

C++98

In C++98 before the introduction of move semantics the special member functions were:

• Default constructor (if no other constructor is explicitly declared)
• Copy constructor
• Copy assignment operator
• Destructor