[C++知识库]Item 17: Understand special member function generation.

Effective Modern C++ Item 17 的学习和解读。

在 C++ 中，对于某些特殊成员函数，如果我们没有申明，编译器会自动生成它们。

在 C++98 中，这些特殊成员函数包括默认构造函数、析构函数、拷贝构造函数、拷贝赋值操作。编译器生成这些构造函数的原则是：当你没有申明它们，并且需要使用到它们。编译器生成的这些特殊函数，并且一般是 public 、 inline 和 nonvirtual 的。派生类中的析构函数有点特殊，当这个派生类继承自 virtual 析构函数的基类，在这种情况下，派生类中，编译器生成的析构函数也是 virtual 的。

两个 copy 操作是独立的：声明一个不会阻止编译器生成另外一个。所以如果你声明了一个拷贝构造函数，但是没有声明拷贝赋值操作 ，然后你需要用到拷贝赋值，编译器将帮你生成一个拷贝赋值操作。类似的，如果你声明了一个拷贝赋值操作，但没有声明拷贝构造函数，然后你的代码需要拷贝构造，编译器将帮你生成一个拷贝构造函数。

你也许听过三法则（The Rule of Three）：如果你声明了任何一个拷贝构造函数，拷贝赋值操作或析构函数，那么你应该声明所有的这三个函数。三法则的建议来源于这样的：当拷贝构造、拷贝赋值或者析构函数不能胜任时候，往往是类要管理某些资源（通常是内存资源），当需要在拷贝中对资源进行管理，那么也需要在析构函数中对资源也进行管理（通常是释放内存），反之亦然。

在 C++11 中，多了两个特殊成员函数：移动构造函数和移动赋值操作：

class Widget {
public:
  ...
  Widget(Widget&& rhs);             // move constructor
  Widget& operator=(Widget&& rhs);  // move assignment operator
  ...
};

新增的两个 move 函数生成的规则也是类似的：当你没有申明，并且代码需要使用，编译器就会替你生成。看个例子：

#include <iostream>
#include <string>

class strA {
 public:
  strA () {
    str = "=====hello====";
  }
  std::string str;
};

int main() {
  strA s1;
  strA s2(std::move(s1));
  std::cout << "=== s1.str = " << s1.str << std::endl;
  std::cout << "=== s2.str = " << s2.str << std::endl;
  return 0;
}

// 结果：
=== s1.str = 
=== s2.str = =====hello====

这个例子，编译器就会自动生成 move 构造函数。

但是，实际上当我们对一个类使用移动构造的时候，编译器并不保证一定是移动构造，因为这个类并不一定具备移动语义，这时候会用拷贝来代替。看这个例子：

class A {
 public:
  A () {
    p = new int(5);
    std::cout << "====construction====" << std::endl;
  }

  int *p = nullptr;
};

int main() {
  A a;
  A b(std::move(a));
  std::cout << "==== a.p = " << a.p << std::endl;
  std::cout << "==== b.p = " << b.p << std::endl;
  std::cout << "==== *(a.p) = " << *(a.p) << std::endl;
  std::cout << "==== *(b.p) = " << *(b.p) << std::endl;
  return 0;
}

// 结果：
====construction====
==== a.p = 0x1742c20
==== b.p = 0x1742c20
==== *(a.p) = 5
==== *(b.p) = 5

这里的 A b(std::move(a)); 实际上是调用的编译器生成的拷贝构造函数。

两个 move 函数不是独立的：如果你声明了任何一个，那就阻止了编译器生成另外一个。也就是说，如果你声明了一个 move 构造函数，那就表明默认的 memberwise move 对这个类来说是不胜任的，那么编译器会认为 默认的 memberwise move 赋值函数也是不能胜任的。所以声明一个 move 构造函数会阻止一个move 复制操作函数被自动生成，声明一个 move 赋值操作函数会阻止一个 move 构造函数被自动生成。

另外，如果任何类显式地声明了一个 copy 操作，两个move 操作就不会被自动生成。这样做的理由是：声明一个 copy 操作表明了用默认的 memberwise copy 来拷贝对象对于这个类来说是不合适的，然后编译器认为，如果对于 copy 操作来说memberwise copy 不合适，那么对于 move 操作来说 memberwise move 很有可能也是不合适的。将上面第一个例子添加一个拷贝构造函数：

#include <iostream>
#include <string>

class strA {
 public:
  strA () {
    str = "=====hello====";
  }
  
  strA (const strA& a) {
    std::cout << "== copy construction ==" << std::endl;
  }
  
  std::string str;
};

int main() {
  strA s1;
  strA s2(std::move(s1));
  std::cout << "=== s1.str = " << s1.str << std::endl;
  std::cout << "=== s2.str = " << s2.str << std::endl;
  return 0;
}

// 结果：
== copy construction ==
=== s1.str = =====hello====
=== s2.str = 

这个例子可以看到：定义了 copy 构造函数，阻止了编译器生成 move 构造函数。

三法则的一个结论是：当类中出现一个用户自定义的析构函数，则表示简单的 memberwise copy 可能不太适合 copy 操作。这反过来就建议：如果一个类声明了一个析构函数，copy 操作可能不应该被自动生成，因为它们可能将作出一些不正确的事。在 C++98 被采用的时候，这个原因的重要性没有被发现，所以在C++98中，用户自定义的析构函数的存在不会影响编译器生成 copy 操作。这种情况在 C++11 中还是存在的，但是这只是因为条件的限制（如果阻止 copy 操作的生成会破坏太多的遗留代码）。

但是，三法则背后的考量还是有效的，并且，结合之前的观察：copy 操作的声明阻止隐式 move 操作的生成。这使得在C++11 中，一个类中有一个用户自定义的析构函数时，则编译器不会生成 move 操作。

因此：只在下面三个条件为真的时候，编译器才为类生成 move 操作（当需要的时候）：

• 没有 copy 操作在类中被声明。
• 没有 move 操作在类中被声明。
• 没有析构函数在类中被声明。

并且，当用户自定义了 move 操作时候，编译器也会认为默认的 memberwise copy 也是不适合的，也会阻止两个 copy 函数被自动生成。

如果你想突破这些限制：用户自定义的 copy 构造函数阻止了编译器生成 move 构造函数，但是如果编译器生成的函数提供的行为是正确的，也就是说如果 memberwise move 就是你想要的，C++11的 “=default” 可以帮助你：

#include <iostream>
#include <string>

class strA {
 public:
  strA () {
    str = "=====hello====";
  }
  
  strA (const strA& a) {
    std::cout << "== copy construction ==" << std::endl;
  }
  
  strA (strA&& a) = default;
  
  std::string str;
};

int main() {
  strA s1;
  strA s2(std::move(s1));
  std::cout << "=== s1.str = " << s1.str << std::endl;
  std::cout << "=== s2.str = " << s2.str << std::endl;
  return 0;
}

// 结果：
=== s1.str = 
=== s2.str = =====hello====

总结 C++11 特殊成员函数生成的规则：
因此C++11对特殊成员函数的控制规则是这样的：

默认构造函数：

• 和C++98中的规则一样，只在类中没有用户自定义的构造函数时生成。

析构函数：

• 本质上和 C++98 的规则一样;
• 唯一的不同就是析构函数默认声明为 noexcept（看Item 14）。
• 和 C++98 一样，只有基类的析构函数是 virtual 时，析构函数才会是 virtual。

拷贝构造函数：

• 和 C++98 一样的运行期行为：memberwise 拷贝构造 non-static 成员变量。
• 只在类中没有用户自定义拷贝构造函数时被生成。
• 如果类中声明了一个move操作，它就会被删除（声明为 delete ）。
• 在有用户自定义拷贝 operator= 或析构函数时，这个函数能被生成，但是这种生成方法是被弃用的。

拷贝 operator= ：

• 和 C++98 一样的运行期行为：memberwise 拷贝赋值 on-static 成员变量。
• 只在类中没有用户自定义拷贝 operator= 时被生成。
• 如果类中声明了一个 move 操作，它就会被删除（声明为 delete ）。
• 在有用户自定义拷贝构造函数或析构函数时，这个函数能被生成，但是这种生成方法是被弃用的。

move构造函数和move operator=：

• 每个都对 non-static 成员变量执行 memberwise move。
• 只有类中没有用户自定义拷贝操作、move 操作或析构函数时被生成。

需要注意的是：关于成员函数模板的存在，没有规则规定它会阻止编译器生成特殊成员函数。

class Widget {
  ...
  template<typename T>
  Widget(const T& rhs);
  
  template<typename T>
  Widget& operator=(const T& rhs);
  ...
};

即使这些 template 能实例化出拷贝构造函数和拷贝 operator= 的函数签名（就是 T 是 Widget 的情况），编译器仍然会为Widget 生成 copy 和 move 操作。Item 26 会解释这个边缘情况。

总结一下：

• 特殊成员函数是那些编译器可能自己帮我们生成的函数：默认构造函数，析构函数，copy 操作，move 操作。
• 只有在类中没有显式声明的 move 操作，copy 操作和析构函数时，move 操作才被自动生成。
• 只有在类中没有显式声明的拷贝构造函数的时候，拷贝构造函数才被自动生成。只要存在 move 操作的声明，拷贝构造函数就会被删除（delete）。拷贝 operator= 和拷贝构造函数的情况类似。在有显式声明的 copy 操作或析构函数时，另一个 copy 操作能被生成，但是这种生成方法是被弃用的。
• 成员函数模板永远不会抑制特殊成员函数的生成。