Special member functions

Special member functions[1] 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:

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.

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).

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>
#include <utility>

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

  explicit Explicit(std::string message) : message_(std::move(message)) {
    std::cout << "Non-default constructor " << message_ << '\n';
  }

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

  Explicit& operator=(const Explicit& 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:
  friend class Implicit;
  std::string message_;
};

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

 private:
  Explicit member_;
};

Signatures

Here are the signatures of the special member functions:

Functionsyntax for class MyClass
Default constructorMyClass();
Copy constructorMyClass(const MyClass& other);
Move constructorMyClass(MyClass&& other) noexcept;
Copy assignment operatorMyClass& operator=(const MyClass& other);
Move assignment operatorMyClass& operator=(MyClass&& other) noexcept;
Destructor~MyClass();

C++03

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

References
  1. ISO/IEC (2011). ISO/IEC 14882:2011 (3 ed.). ISO/IEC. pp. §12.
  2. "Enforcing the Rule of Zero".
  3. Except for the destructor if a base class already has a virtual destructor.
  4. ISO/IEC (1998). International Standard ISO/IEC 14882: Programming languages—C++ = Languages de programmation—C++ (1 ed.). ISO/IEC. pp. §12. OCLC 71718919.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.