Special member functions

In the C++ programming language, special member functions^[1] 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^[2] ).

• 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 ^[3] and the copy constructor and assignment operators will receive const& parameters (and not be of the alternative legal forms).^[4]

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>
#include<utility>
classExplicit{
public:
Explicit(){std::cout<<"Default constructor "<<message_<<'\n';}
explicitExplicit(std::stringmessage):message_(std::move(message)){
std::cout<<"Non-default constructor "<<message_<<'\n';
}
Explicit(constExplicit&other){
std::cout<<"Copy constructor "<<message_<<'\n';
*this=other;// invoke copy assignment operator
}
Explicit&operator=(constExplicit&other){
std::cout<<"Copy assignment operator "<<message_<<'\n';
if(this!=&other){
message_=other.message_;
}
return*this;
}
Explicit(Explicit&&other)noexcept{
std::cout<<"Move constructor "<<message_<<'\n';
*this=std::move(other);// invoke move assignment operator
}
Explicit&operator=(Explicit&&other)noexcept{
std::cout<<"Move assignment operator "<<message_<<'\n';
if(this!=&other){
message_=std::move(other.message_);
}
return*this;
}
~Explicit(){std::cout<<"Destructor "<<message_<<'\n';}
private:
friendclassImplicit;
std::stringmessage_;
};
classImplicit:publicExplicit{
public:
voidSpew(){
std::cout<<"Implicit("<<message_<<", "<<member_.message_<<")\n";
}
private:
Explicitmember_;
};

Here are the signatures of the special member functions:

In C++03 before the introduction of move semantics (in C++11) the special member functions^[5] were:

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

• C++

• Articles with short description
• Short description is different from Wikidata
• Use dmy dates from December 2020
• Articles with example C++ code