条款05:Know what function C++ silently writes and calls
如果没有显式声明,编译器会自动为class创建default构造函数、copy构造函数、copy assignm操作符以及析构函数。显式声明这些函数或在base class中将这些函数声明为private可以阻止编译器的这一行为。
如果class内含const或reference成员,那么编译器将拒绝为其自动生成copy assignment操作符。
条款06:Explicitly disallow the use of compiler-generated functions you do not want
如果你想阻止class的copying行为,你可以将copy构造函数和copy assignment操作符声明为private,同时不提供定义,这正是标准库iostream的做法。
考虑如下类:
class Unique {
public:
...
Unique() {}
~Unique() {}
private:
...
Unique(const Unique&); //只有声明
Unique& operator=(const Unique&);
};
当用户试图拷贝该类的对象时,编译器就会报错;如果在member函数或friend函数中这么做,链接器会报错。
将链接期错误移至编译期可以尽早检测到错误。为此,我们需要一个专门为了阻止copying行为而设计的base class:
class Uncopyable {
protected:
Uncopyable() {} //允许derived对象构造和析构
~Uncopyable() {}
private:
Uncopyable(const Uncopyable&); //但阻止copying
Uncopyable& operator=(const Uncopyable&);
};
为阻止class C的对象被拷贝,我们只需让C继承Uncopyable:
class C : private Uncopyable {
... //不要声明copy构造函数或copy assignment操作符
};
在class C内我们不再声明copy构造函数和copy assignment操作符,于是编译器就会尝试自己合成它们,但由于其无权调用base class的对应版本,结果只能以失败告终。
条款07:Declare destructors virtual in polymorphic base classes
如果多态基类的析构函数是non-virtual的,那么析构函数将静态绑定,我们就不能经由一个base class指针删除一个derived对象。若这么做,结果未定义——通常发生的是对象的derived成分没被销毁。任何class只要带有virtual函数都几乎确定该有一个virtual析构函数。
Pure virtual函数导致abstract classes,也就是不能被实例化的class。有时候你希望有一个抽象class,但手上没有任何pure virtual函数,这时可以创建一个pure virtual析构函数。
class AWOV { // AWOV = "Abstract w/o Virtuals"
public:
virtual ~AWOV() = 0;
};
然而,你必须为pure virtual析构函数提供一份定义:
AWOV::~AWOV() {} // 如果不提供定义,链接器将会报错
这是因为AWOV的derived class的析构函数将调用AWOV的析构函数。若不提供定义,链接目标文件时将出错。
条款08:Prevent exceptions from leaving destructors
绝对不要在析构函数中吐出异常。如果一个被析构函数调用的函数可能抛出异常,析构函数应该捕捉任何异常,然后屯下它们或结束程序。
如果客户需要对某个操作函数运行期间抛出的异常做出反应,那么class应该提供一个普通函数(而非在析构函数中)执行该操作。
条款09:Never call virtual functions during construction or destruction
#include <iostream>
class Base {
public:
Base() {
init();
}
virtual void init() {
std::cout << "base constructor." << std::endl;
}
virtual void clean() {
std::cout << "base destructor." << std::endl;
}
~Base() {
clean();
}
};
class Derived : public Base {
public:
virtual void init() {
std::cout << "derived constructor." << std::endl;
}
virtual void clean() {
std::cout << "derived destructor." << std::endl;
}
};
int main() {
Derived d;
}
程序运行后输出:
base constructor.
base destructor.
可能并不是你想要的结果。这是因为derived class对象在构造base class成分时,它的类型还只是base class,因此调用的virtual函数版本也是base class的。
条款10:Have assignment operators return a reference to *this
书上说,为了实现连锁赋值,赋值操作符必须返回一个reference指向操作符的左侧实参。但是测试发现,就算不返回reference也能实现连锁赋值。
class Integer {
public:
Integer(int value = 0) : value(value) {}
Integer operator=(const Integer &rhs) {
value = rhs.value;
return *this;
}
void print() {
std::cout << value << std::endl;
}
private:
int value;
};
int main() {
Integer x(1), y(2), z(3);
x = y = z;
x.print(); //输出3
}
当然,即便如此,我们还是应该令operator=返回一个reference,无疑这样的效率最高。我想这才是所有内置类型和标准库类型遵守这个原则的真正原因吧。
条款11:Handle assignment to self in operator=
自我赋值发生在对象被赋值给自己时:
class Widget {...};
Widget w;
...
w = w;
这看起来有点愚蠢,但却是合法的,不要认定客户不会这么做。
还有一些自我赋值不那么明显,如:
a[i] = a[j]; //若i == j,则为潜在的自我赋值
*px = *py; //若px和py指向同一对象,则为潜在的自我赋值
事实上,别名(包括指针和引用)使得指涉一个对象的方法不只一个,大大增加了自我赋值的可能性。特别是在继承体系中,base class的指针或引用可以指向一个derived
class对象,两个对象甚至不需要声明为相同类型就可能造成别名。
考虑如下类:
class Text {
public:
Text(const char *ps);
Text(const Text &rhs);
Text& operator=(const Text &rhs);
~Text();
std::string toString() const;
private:
char *ps;
};
Text::Text(const char *ps) {
this->ps = new char[strlen(ps) + 1];
strcpy(this->ps, ps);
}
Text::Text(const Text &rhs) {
ps = new char[strlen(rhs.ps) + 1];
strcpy(ps, rhs.ps);
}
Text&
Text::operator=(const Text &rhs) {
delete []ps;
ps = new char[strlen(rhs.ps) + 1];
strcpy(ps, rhs.ps);
return *this;
}
Text::~Text() {
delete []ps;
}
std::string Text::toString() const {
return std::string(ps);
}
Text对象在进行自我赋值时出现的问题很明显,strlen的调用将以一个以销毁的字符串为实参,更不用说之后的一系列操作了。避免这种错误最简单的方法是进行identity test:
Text&
Text::operator=(const Text &rhs) {
if (this == &rhs) return *this;
delete []ps;
ps = new char[strlen(rhs.ps) + 1];
strcpy(ps, rhs.ps);
return *this;
}
这样,修改后的operator=已经获得了“自我赋值安全性”,但它仍不具备“异常安全性”。具体来讲,当new操作失败时,Text最终会持有一个指向被删除的字符串的指针。
幸运的是,具有“异常安全性”的operator=往往具有“自我赋值安全性”,因此,我们只需将焦点放在实现“异常安全性”上。
Text&
Text::operator=(const Text &rhs) {
char *pOrg1 = ps, *pOrg2 = rhs.ps;
ps = new char[strlen(rhs.ps) + 1];
strcpy(ps, pOrg2);
delete []pOrg1;
return *this;
}
这里我们用了两个指针来记录原来的ps和rhs.ps,pOrg1是为了最后能删除原来的ps,pOrg2是为了发生自我赋值时strcpy能获取原来的rhs.ps。
往往一组精心组织的语句可以帮我们实现“异常安全性”,除此之外,我们还可以使用所谓的copy and swap技术,其基本做法是:为要修改的对象创建一个副本,然后在副本上进行修改,最后交换副本和原对象的数据。这样,即使修改过程中抛出了异常,原对象仍可以保持不变。
首先为Text类添加一个swap成员函数:
void Text::swap(Text &rhs) {
std::swap(ps, rhs.ps);
}
然后利用它实现operator=:
Text&
Text::operator=(const Text &rhs) {
Text temp(rhs);
swap(temp);
return *this;
}
总结:确保“自我赋值安全性”的方法有三种,分别是测试操作数,精心组织语句以及copy and swap技术。其中后两种方法同时实现了“异常安全性”。特别是copy and swap技术,不仅代码简洁,而且逻辑清晰,非常值得学习。
条款12:Copy all parts of an object
Copying函数应该确保复制对象内的所有成员变量以及所有base class成分。