Effective C++ 之 Item 5:了解C++默默编写并调用哪些函数

Effective C++

chapter 2. 构造 / 析构 / 赋值运算

                 (Constructors, Destructors, and Assignment Operators)

     Item 5. 了解 C++ 默默编写并调用哪些函数

                 (Know what functions C++ silently writes and calls)

 

当 C++ 处理过一个 empty class (空类)之后,其便不再是一个 empty class。如果你自己没有声明,编译器就会为它声明(编译器版本的)一个 copy 构造函数、一个 copy assignment 操作符和一个析构函数。此外如果没有声明任何构造函数,编译器也会声明一个 default 构造函数。所有这些函数都是 public 且 inline (见 Item 30)。因此,如果写下:

class Empty { };

这就好像写下这样的代码:

class Empty

{

public:

    Empty() { ... }                               // default 构造函数

    Empty(const Empty& rhs) { ... }               // copy 构造函数

    ~Empty() { ... }                              //析构函数,是否该是 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(见 Item 7),除非这个 class 的 base class 自身声明有 virtual 析构函数(这种情况下这个函数的虚属性主要来自 base class)。

至于 copy 构造函数和 copy assignment 操作符,编译器创建的版本只是单纯地将来源对象的每一个 non-static 成员变量拷贝到目标对象。考虑一个 NamedObject template,它允许将一个个名称和类型为 T 的对象产生关联:

template<typename T>

class NamedObject

{

public:

    NamedObject(const char* name, const T& value);

    NamedObjectt(const std::string& name, const T& value);

    ...

private:

    std::string nameValue;

    T objectValue;

};

由于其中声明了一个构造函数,编译器于是不再为它创建 default 构造函数。这意味着你用心设计一个 class,其构造函数要求实参,你就无需担心编译器会毫无挂虑地为你添加一个无实参构造函数(即 default 构造函数)而遮盖掉你的版本。

NamedObject 既没有声明 copy 构造函数,也没有声明 copy assignment 操作符,所以编译器会为它创建那些函数(如果它们被调用的话)。现在,看看 copy 构造函数的用法:

NamedObject<int> no1("Smallest Prime Number", 2);

NamedObject<int> no2(no1);                               // 调用 copy 构造函数

编译器生成的 copy 构造函数必须以 no1.nameValue 和 no1.objectValue 为初值设定 no2.nameValue 和 no2.objectValue。两者之中,nameValue 的类型是 string, 而标准 string 有个 copy 构造函数,所以 no2.nameValue 的初始化方式是调用 string 的 copy 构造函数并以 no1.nameValue 为实参。另一个成员 NamedObject<int>::objectValue 的类型是 int (因为对此 template 具现体而言 T 是 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* 构造函数已经过去了,因为必须有个 string 可供指涉。

    NamedObject(std::string& name, const T& value);

    ...                             // 如前,假设并未声明 operator=

private:

    std::string& nameValue;         //这如今是个 reference

    const T objectValue;            // 这如今是个 const

};

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

std::string newDog("Persephone");

std::string oldDog("Satch");

NamedObject<int> p(newDog, 2);

NamedObject<int> s(oldDog, 36);

p = s;                                // 现在 p 的成员变量该发生什么事?

赋值之前,不论 p.nameValue 和 s.nameValue 都指向 string 对象(当然不是同一个)。赋值之后 p.nameValue 应该指向 s.nameValue 所指向的那个 string 吗?也就是说 reference 自身可被改动吗?如果是,那可就开辟了新天地,因为 C++ 并不允许“让 reference 改指向不同对象”。换一个想法,p.nameValue 所指向的那个 string 对象该被修改,进而影响“持有 pointers 或 references 而且指向该 string”的其他对象吗?也就是对象不被直接牵扯到赋值操作内?编译器生成的 copy assignment 操作符究竟该怎么做呢?

面对这个难题,C++ 的响应是拒绝编译那一行赋值动作。如果你打算在一个“内含 reference 成员”的 class 内支持赋值操作(assignment),你必须自己定义 copy assignment 操作符。面对“内含 const 成员”(如本例的 objectValue)的 classes,编译器的反应也是一样。更改 const 成员是不合法的,所有编译器不知道如何在它自己生成的赋值函数内面对它们。最后还有一种情况:如果某个 base classes 将 copy assignment 操作符申明为 private,编译器将拒绝为其 derived classes 生成一个 copy assignment 操作符。毕竟编译器为 derived classes 所生的 copy assignment 操作符想象中可以处理 base class 成分(见 Item 12),但它们当然无法调用 derived class 无权调用的成员函数。编译器无能无力。

 

请记住:

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

 

 

 

    

你可能感兴趣的:(effective)