条款05:了解C++默默编写并调用哪些函数
Know what functions C++ silently writes and calls
编译器会为空类生成一个copy构造函数、copy assignment操作符和一个析构函数。此外如果你没有声明任何构造函数,它也会生成一个默认构造函数。
(对C++11,应该是还会生成移动构造函数和移动赋值运算符。同时,当用户自定义移动构造函数,或移动赋值运算符,或拷贝构造函数,或拷贝赋值运算符,或析构函数时,编译器不会自动生成移动构造函数和移动赋值运算符)
这里延伸出来一个五法则:当你显式定义上述五个函数其中之一时,则需要同时显式定义其余四个。
默认生成的copy构造函数和copy assignment操作符只是单纯的将源对象中的每一个non-static成员变量拷贝到目标对象(浅拷贝)。
若一个类中存在const成员或引用成员,则不能使用默认生成的拷贝赋值操作符。
条款06:若不想使用编译器自动生成的函数,就该明确拒绝
Explicitly disallow the use of compiler-generated functions you do not want
假设一个类为 class HomeForSale {...},我们不允许其拷贝。
HomeForSale h1;
HomeForSale h2;
HomeForSale h3(h1); //企图拷贝h1,不该通过编译
h1 = h2; //企图拷贝h2,也不该通过编译
方法一:
将拷贝构造函数和拷贝赋值操作符定义为private,并不实现它们。(编译器会阻止客户企图调用,连接器会阻止成员函数和友元函数的调用)
class HomeForSale{
public:
...
private:
...
HomeForSale(const HomeForSale&)
HomeForSale operator=(const HomeForSale&)
}
方法二:
继承一个Uncopyable接口,任何人尝试拷贝HomeForSale对象,编译器会尝试生成对应的拷贝构造函数和拷贝赋值操作符。这些函数的“编译器生成版”会尝试调用base class的对应兄弟,那些调用会被编译器拒绝,因为其是private(还可以将连接期错误移至编译期)
class Uncopyable{
protected:
Uncopyable() {}
~Uncopyable() {}
private:
Uncopyable(const Uncopyable&);
Uncopyable& operator=(const Uncopyable&);
}
class HomeForSale: private Uncopyable{
...
};
方法三?:
好像这本书出版的时候c++11还没出来,所以没提到delete这个最简单的方法?
class HomeForSale{
public:
...
private:
HomeForSale(const HomeForSale&) = delete
HomeForSale operator=(const HomeForSale&) =delete
}
条款07:为多态基类声明 virtual 析构函数
Declare destructors virtual in polymorphic base classes
当derived class对象经由一个base指针被删除,而该base带着一个non-virtual析构函数,其结果未有定义 - 实际执行时通常发生的是对象的derived成分没被销毁。(解决方法是将base的析构函数声明为virtual)
任何class只要带有virtual函数都几乎确定应该也有一个virtual析构函数。
虚函数表主要存储的是指向一个类的虚函数地址的指针,通过使用虚函数表,继承、覆盖的问题都都得到了解决。假如一个类有虚函数,当我们构建这个类的实例时,将会额外分配一个指向该类虚函数表的指针,当我们用父类的指针来操作一个子类的时候,这个指向虚函数表的指针就派上用场了,它指明了此时应该使用哪个虚函数表,而虚函数表本身就像一个地图一样,为编译器指明了实际所应该调用的函数。
虚函数表会占内存,无端的将所有classes析构函数声明为virtual,就像从未声明它们为virtual一样,都是错误的。
继承一个“带有non-virtual析构函数”的class的问题和第一段一样,不会正确对derived class内存进行释放。
请记住:
- polymorphic base classes应该声明一个virtual析构函数。如果class带有任何virtual函数,它就应该拥有一个virtual析构函数。
- classes的设计目的如果不是作为base classes使用,或不是为了具有多态性,就不该声明virtual析构函数。
条款08:别让异常逃离析构函数
Prevent exceptions from leaving destructors
C++并不禁止析构函数吐出异常,但它不鼓励你这样做。
class Widget {
public:
...
~Widget() {...} //假设可能抛出异常
}
void doSomething()
{
std::vector<Widget> v;
...
}
在析构vector第一个元素期间,有个异常被抛出,其他几个还是应该被销毁(否则它们保存的任何资源都会被泄露)。但如果第二个Widget析构函数又抛出异常,对于C++而言,在两个异常同时存在的情况下,程序若不是结束执行就是导致不明确行为。
但如果你的析构函数必须执行一个动作,该动作可能会在失败时抛出异常,该怎么办。
class DBConnection{
public:
...
static DBConnection create();
void close();
}
//为保证客户调用DBConnection的close,可以创建一个资源类来管理它,并在析构函数中调用close
class DBConn {
public:
...
~DBConn()
{
db.close();
}
private:
DBConnection db;
}
这便允许客户写出
{
DBConn dbc(DBConnection::create());
}
但如果close调用导致异常(结束时,})DBConn析构函数会传播该异常。因此需要避免这个问题。
方法一:close抛出异常就结束程序,调用abort(如果是一个遇到就无法继续执行的异常)
DBConn::~DBConn()
{
try{db.close();}
catch(...)
{
log();
std::abort();
}
}
方法二:吞下因调用close而发生的异常:
DBConn::~DBConn()
{
try{db.close();}
catch(...)
{
log();
}
}
一个好一点的策略是,提供一个close函数给客户机会关闭连接。
class DBConn{
public:
...
void close()
{
db.close();
closed = true;
}
~DBConn()
{
if (!closed)
{
try{db.close();}
catch(...) { ... ;}
}
}
private:
DBConnection db;
bool closed;
}
请记住:
- 析构函数绝对不要吐出异常。如果一个被析构函数调用的函数可能抛出异常,析构函数应该捕捉任何异常,然后吞下他们或结束程序。
- 如果客户需要对某个操作函数运行期间抛出的异常做出反应,那么class应该提供一个普通函数(非析构函数)执行该操作。
条款09:绝不在构造和析构函数中调用virtual函数
Never call virtual functions during construction or destruction
class Transaction{
public:
Transaction();
virtual void logTransaction() const = 0;
}
Transaction::Transaction()
{
logTransaction();
}
class BuyTransaction: public Transaction{
public:
virtual void logTransaction() const;
}
class SellTransaction: public Transaction{
public:
virtual void logTransaction() const;
}
当构建一个BuyTransaction对象时,Transaction构造函数首先被调用,此时只会调用Transaction自己的log函数,而不是子类的(derived class对象的base class构造期间,对象是base class而不是derived class)。相同道理也适用于析构函数。
一个简单的方案可以解决这个问题。
class Transaction{
public:
explicit Transaction(const std::string& logInfo);
void logTransaction(const std::string& logInfo) const;
}
Transaction::Transaction(const std::string& logInfo)
{
logTransaction(logInfo);
}
class BuyTransaction: public Transaction{
public:
BuyTransaction(parameters) : Transaction(createLogString(parameters)) {}
private:
static std::string createLogString(parameters);
}
请记住:
在构造和析构期间不要调用virtual函数,因为这类调用从不下降至derived class(比起当前执行构造函数和析构函数那层)
条款10:令operator=返回一个reference to *this
Have assignment operators return a reference to *this
int x, y, z;
x = y = z = 15; //等价于 x = (y = (z = 15));
为了实现”连锁赋值“,赋值操作符必须返回一个reference指向操作符的左侧实参,这是为classes实现赋值操作符应该遵循的协议。
class Widget{
public:
Widget& operator=(const Widget& rhs)
{
...
return *this
}
}
条款11:在operator=中处理“自我赋值”
Handle assignment to self in operator=
“自我赋值”发生在对象被赋值给自己时。
class Widget {...}
Widget w;
w = w;
a[i] = a[j]; //潜在的自我赋值
*px = *py;
当你尝试自行管理资源的时候,就要小心
class Bitmap {...};
class Widget {
private:
Bitmap* pb;
}
Widget& Widget::operator=(const Widget& rhs)
{
delete pb;
pb = new Bitmap(*rhs.pb);
return *this;
}
上述代码中,若*this和rhs是同一对象则会造成自己持有一个指针指向一个已被删除的对象。为阻止这种错误,传统方法为添加“证同测试”代码:
if (this = &rhs) return *this;
但这个版本的代码仍存在“异常安全性”的问题。如果"new Bitmap"异常,Widget最终会持有一个指针指向一块被删除的Bitmap,这样的指针有害,你无法安全的删除它们,甚至无法安全的读取它们。
Widget& Widget::operator=(const Widget& rhs)
{
Bitmap* pOrig = pb;
pb = new Bitmap(*rhs.pb);
delete pOrig;
return *this;
}
还有一种解决办法是使用copy and swap技术:
class Widget {
void swap(Widget& rhs);
};
Widget& Widget::operator=(const Widget& rhs)
{
Widget temp(rhs);
swap(temp); //交换*this和rhs的数据,详见条款29
return *this;
}
请记住:
- 确保当对象自我赋值时operator=有良好行为。其中技术包括比较“来源对象”和“目标对象”的地址、正确的语句顺序和copy-and-swap。
- 确定任何函数如果操作一个以上的对象,而其中多个对象是同一个对象时,其行为仍然正确。
条款12:复制对象时勿忘其每一个成分
Copy all parts of an object
class Customer{
public:
Customer(const Customer& rhs);
Customer& operator=(const Customer& rhs);
private:
std::string name;
}
Customer::Customer(const Customer& rhs) : name(rhs.name) {}
Customer& operator=(const Customer& rhs)
{
name= rhs.name;
return *this;
}
上述代码一旦发生继承,可能会造成一个严重的潜藏危机。
class PriorityCustomer: public Customer{
public:
PriorityCustomer(const PriorityCustomer& rhs);
PriorityCustomer& operator=(const PriorityCustomer& rhs);
private:
int priority;
}
PriorityCustomer::PriorityCustomer(const Customer& rhs) : priority(rhs.priority) {}
PriorityCustomer& operator=(const PriorityCustomer& rhs)
{
priority= rhs.priority;
return *this;
}
上述代码没有复制Customer的成员变量。因此,在为“derived class撰写copying函数”时,必须小心的复制其base class成分。
riorityCustomer::PriorityCustomer(const Customer& rhs) : Customer(ths), priority(rhs.priority) {}
PriorityCustomer& operator=(const PriorityCustomer& rhs)
{
Customer::operator=(ths);
priority= rhs.priority;
return *this;
}
同时,请记住一个结论:不该令copy assignment操作符调用copy构造函数,也不该令copy构造函数调用copy assignment操作符。
如果发现copy构造函数和copy assignment操作符有相近代码,正确做法是建立一个新的成员函数给两者调用。这样的函数往往是private且常被命名为init。
请记住:
- Copying函数应该确保复制“对象内所有成员变量”和“所有base class成分”。
- 不该令copy assignment操作符调用copy构造函数,也不该令copy构造函数调用copy assignment操作符。