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

Item 05： Know waht functions C++ silently writes and calls.

---

空类并不一定是空的

什么时候空类不再是个空类呢？答案是：当C++处理过之后。

如果你自己没声明，编译器就会为它声明（编译器版本的）一个拷贝构造函数、一个赋值操作符和一个析构函数。此外如果你没声明任何构造函数，编译器也会为你声明一个默认构造函数。所有这些函数都是public且inline的。

例如，如果你写下：

class Empty{};

这就好像写出下面这样的代码：

class Empty {
public:
    Empty() { ... }                                  // default constructor
    Empty(const Empty& rhs) { ... }                  // copy constructor
    ~Empty() { ... }                               // destructor — 是否该是
                                                     // virtual稍后说明。
    Empty& operator=(const Empty& rhs) { ... }    // copy assignment operator
};

唯有当这些函数被需要（被调用），它们才会被编译器创建出来。程序中需要它们是很平常的事。下面的代码造成上述每一个函数被编译器产生出来：

Empty e1;           // default constructor;
                      // destructor
Empty e2(e1);       // copy constructor
e2 = e1;             // copy assignment operator

编译器为你写出这些函数，但这些函数做了声明呢？默认构造函数和析构函数主要是给编译器一个地方用来放置“藏身幕后”的代码，像调用base classes和non-static成员变量的构造函数和析构函数。

注意，编译器产生出的析构函数是个non-virtual，除非这个class的base class自身声明有vitual析构函数。（这种情况下这个函数的虚属性主要来自base class）。

至于拷贝构造函数和赋值操作符，编译器创建的版本知识单纯地将来源对象的每一个non-static成员变量拷贝到目标对象。

拷贝构造函数

考虑一个NameObject 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构造函数。NamedObject既没有声明拷贝构造函数，也没有声明赋值操作符，所以编译器会为它创建那些函数（如果它们被调用的话）。

NamedObject<int> no1("Smallest Prime Number", 2);
NamedObject<int> no2(no1);                          // calls copy constructor

编译器生成的拷贝构造函数必须以no1.nameValue和no1.objectValue为初值设定no2.nameValue和no2.objectValue。两者之中，nameVlaue的类型是string，而标准的string有个拷贝构造函数，所以no2.nameValue的初始化式是调用string的拷贝构造函数并以no1.nameValue为实参。另一个成员NamedObject::objectValue的类型是int，那是个内置类型，所以no2.objectValue会以“拷贝no1.objectValue内的每一个bits”来完成初始化。

拷贝赋值操作符

编译器为NamedObject所产生的赋值操作符，其行为基本上与拷贝构造函数一样，但一般而言只有当产生出的代码合法且有适当机会证明它有意义，其表现才会和我们预期的一样。万一有条件不符合，编译器会拒绝为class生出operator=。

举个例子，假设NamedObject定义如下，其中nameValue是个引用，objectValue是个const T：

template<typename T>
class NamedObject {
public:
    NamedObject(std::string& name, const T& value);
    ... 
private:
    std::string& nameValue;      // this is now a reference
    const T objectValue;        // this is now const
};

现在考虑下面会发生什么事：

std::string newDog("A");
std::string oldDog("B");

NamedObject<int> p(newDog, 2); 

NamedObject<int> s(oldDog, 36); 

p = s;      //what should happen to the data members in p?

赋值之前，不论p.nameValue和s.nameVlaue都指向string对象（当然不是同一个）。赋值动作该如何影响p.nameValue呢？赋值之后，p.nameValue应该是指向s.nameValue所指的那个string吗？也就是说reference自身可被改动吗？

面对这个难题，C++的响应是拒绝编译那一行赋值动作。因为C++并不允许“让reference改指向不同对象”。同样道理更改变const值也是非法的。如果某个base class将拷贝赋值操作符声明为private，编译器也拒绝为其derived class产生出一个拷贝赋值操作符。因为编译器为derived class生成的拷贝赋值操作符想象中可以处理base class成分，这是做不到的。

来一个具体一点的例子：

class Person{
public:
    Person(string& str,int x): name(str),value(x){ }

    string & name;
    const int value;
};


int main()
{
    string s1 = "A", s2 = "B";
    Person p1(s1,1),p2(s2,2);
    Person p3(p2);          //拷贝构造函数可以正常调用，和预期结果一样。

    cout << p1.name << " " << p1.value << endl;     //A 1
    cout << p2.name << " " << p2.value << endl;     //B 2
    cout << p3.name << " " << p3.value << endl;     //B 2

    p1 = p2;    //编译错误
                //error: non-static reference member 'std::string& Person::name', can't use default assignment operator
                //error: non-static const member 'const int Person::value', can't use default assignment operator

    return 0;
}

Note：

• 编译器可以为class创建默认构造函数、拷贝构造函数、拷贝赋值操作符，以及析构函数。
• 只有这些函数被调用的时候，它们才会被编译器创建出来。
• 生成的析构函数是否为vitual，根据base class而定。
• 如果你显式的任意定义了一个构造函数，编译器就不会为你生成一个默认构造函数了。
• 打算在一个“内含reference成员”的 class 内支持 赋值操作，必须自己定义copy assignment操作符。
• 面对“内含const成员”的classes，编译器的反应也一样，因为更改const成员是不合法的。
• 如果某个 base classes 将copy assignment操作符声明为 private，编译器将拒绝为其 derived classes 生成 copy assignment 操作符。