条款05：了解C++默默编写并调用了哪些函数

条款05：了解C++默默编写并调用了哪些函数

Know what functions C++ silently writes and calls.

首先，对于一个空类（empty class），在C++处理过它之后，它便不再是一个空类了。
当用户没有对它进行声明，编译器会自动为它声明（编译器版本）：

• 一个copy构造函数
• 一个copy assignment操作符
• 一个析构函数

另外，如果用户也没有声明任何构造函数，编译器也会自动声明：

• 一个default构造函数

这些函数都是public、inline。
举个例子，假如定义了如下的类：

class Empty { };

就好像写下了如下代码：

class Empty {
public:
    Empty() { ... };                             //default构造函数
    Empty(const Empty& rhs) { ... }              //copy构造函数
    ~Empty() { ... }                             //析构函数（non-virtual）
    Empty& operator=(const Empty& rhs) { ... }   //copy assignment操作符

在上面的代码中，只有当这些函数被需要（被调用），它们才会被编译器创建出来

Empty e1;       //default构造函数
                //析构函数
Empty e2(e1);   //copy构造函数
e2 = e1;        //copy assignment操作符

对于这些编译器创建的函数而言：

• default构造函数和析构函数
  主要是为编译器提提供一个地方来放置“藏身幕后”的代码，就像是调用base classes和non-static成员变量的构造函数和析构函数。
  需要注意的是，编译器提供的析构函数是non-virtual，除非这个class的base class自身声明有virtual析构函数。
• copy构造函数和copy assignment操作符
  这里，编译器创建的版本，仅仅是将来源对象的每一个non-static成员变量拷贝到目标对象。

考虑一个NamedObject template，它允许名称和类型为T的对象进行关联：

template<typename T>
class NamedObject{
public:
    NamedObject(const char* name, const T& value);   //声明了两个构造函数
    NamedObject(const std::string& name, const T& value);
    ...
private:
    std::string nameValue;
    T objectValue;
};

在上面的这段代码中，用户自己声明了一个构造函数，因此编译器不会再为其创建default构造函数。
也就是说，编译器胡乱创建一个无参的default构造函数来掩盖掉用户自己编写的构造函数。

上面的NamedObject既没有声明copy构造函数，又没有声明copy assignment操作符，因此，编译器会在他们被调用时，会自动创建这些函数：

NamedObject<int> no1("Smallest Prime Number", 2);
NamedObject<int> no2(no1);      //调用了拷贝构造函数

在这段代码中，编译器所生成的copy构造函数必须以no1.nameValue和no1.objectValue为初值，设定no2.nameValue和no2.objectValue。

• 在上面的二者中，对于第一个成员，nameValue的类型是string，而标准string有一个copy构造函数，因此no2.nameValue的初始化方式是调用string的copy构造函数并以no1.nameValue为实参。
• 而另一个成员NamedObject< int >::objectValue的类型是int，也是一个内置类型，因此no2.objectValue会“拷贝no1.objectValue内的每一个bits”来完成初始化。

另外，编译器为NamedObject< int >所生成的copy assignment操作符，其行为和copy构造函数是一样的。
但是，只有当代码合法且有适当的机会证明它有意义，这样的行为才是一样的。只要有一个条件不满足，编译器就会拒绝为class生成operator=。

举个例子，定义NamedObject，其中nameValue是个reference to string，objectValue是个const T：

template<class T>
class NamedObject {
public:
    //下面的构造函数不会再接受一个const
    //因为nameValue此时定义的是一个reference-to-non-const string
    //目前只有一个构造函数，没有char* 那个构造函数
    NamedObject(std::string& name, const T& value);
    ...            //假设并没有声明operator=
private:
    std::string& nameValue;  //此时，nameValue是一个reference
    const T objectValue;     //此时，objectValue是一个const
};

在定义完NamedObject后，尝试以下代码：

std::string newDog("Persephone");
std::string oldDog("Satch");

NamedObject<int> p(newDog, 2);
NamedObject<int> s(oldDog, 36);

p = s;  

在赋值之前，不管是p.nameValue还是s.nameValue都指向不同的string对象。
然而，C++不允许让reference改指向不同对象

引用的特点：

①一个变量可取多个别名。
②引用必须初始化。
③引用只能在初始化的时候引用一次 ，不能更改为转而引用其他变量。

因此，对于这样的赋值操作，C++会拒绝编译。

假如想让一个“内含reference成员”的class支持赋值操作，则必须去定义这样的copy assignment操作符。

同样的，对于“内含const成员”（例如这个例子中的objectValue）的classes，编译器也会拒绝编译。因为更改const成员是不合法的，所以编译器不知道如何在它自己定义的赋值函数面对const。

另外，假如某个base classes将copy assignment操作符声明为private，编译器也会拒绝为其derived classes生成一个copy assignment操作符。

最后：

编译器可以暗自为class创建default构造函数、copy构造函数、copy assignment操作符，以及析构函数。