EffectC++(二)：构造/析构/赋值运算

条款5：了解C++默默为你编写的三个函数
注意点1：三个函数都是public且inline 且non-virtual.

注意点2：Copy 构造函数 和 CopyAssignment 操作符 会将源对象的每一个非non-static 拷贝的目标对象。

例子：

#include<iostream>
class CTestA
{
public:
void SetValue(int a,int *b)
{
i = a;
j = b;
}
void Show()
{
std::cout<<"i = "<<i<<std::endl;
std::cout<<"j = "<<j<<std::endl;
}

private:
int i;
int *j;
static int k;
};

int main()
{
CTestA a,b;//采用默认构造函数
std::cout<<"defalut a:"<<std::endl;
a.Show();
std::cout<<"defalut b:"<<std::endl;
b.Show();
int i = 0;
int *j = &i;
a.SetValue(i,j);
b = a;
std::cout<<"SetValue a:"<<std::endl;
a.Show();
std::cout<<"Copy assignmentb:"<<std::endl;
b.Show();
CTestA c(a);
std::cout<<"Copy c:"<<std::endl;
c.Show();
return 0;
}

结果：



 

条款6：如果不想使用系统默认的这三个默认函数，需要明确的拒绝。

拒绝的方法：将需要拒绝的函数放置到private区域。

如：

#include<iostream>
class CTestA
{
public:
void SetValue(int a,int *b)
{
i = a;
j = b;
}
void Show()
{
std::cout<<"i ="<<i<<std::endl;
std::cout<<"j ="<<j<<std::endl;
}

private:// 这里
CTestA(const CTestA &other);
CTestA & operator=(const CTestA&other);

private:
int i;
int *j;
static int k;
};

 
条款7：为多态基类声明virtual析构函数
注意点1：如果该类不会作为基类（也就是被其他继承）请不要使用virtual析构函数。另外，请不要继承使用non-virtual析构。
比如：classCTestA:publicstd::string
如果你使用的一个指针指向它，在析构的时候将会步入未定义行为的恶地。
 
技巧点：使用pure析构函数 （纯虚函数）
例：注意到即使使用pure析构函数同样可以再定义。

#include<iostream>
#include<string>
classCTestBase
{
public:
virtual ~CTestBase() = 0;
void SetValue(int a,int *b)
{
i = a;
j = b;
}
void Show()
{
std::cout<<"i ="<<i<<std::endl;
std::cout<<"j ="<<j<<std::endl;
}

private:
int i;
int *j;
};

CTestBase::~CTestBase()
{
std::cout<<"this is~Base"<<std::endl;
}

classCTestDerived:public CTestBase
{
public:
virtual ~CTestDerived();
};

CTestDerived::~CTestDerived()
{
std::cout<<"this is~Derived"<<std::endl;
}

int main()
{
CTestDerived a;
return 0;
}

 
条款8：严禁析构出现异常
注：此处不是谈论异常的处理，而是谈论如何在析构的时候避开异常提示。
此处列举的例子具有具体性，假设一个数据库类，在析构的时候需要断开此连接
例子：
1.      一般不会采用的做法：

classCTestDataBase
{
public:
CTestDataBase()
{
std::cout<<"ConnectDB!"<<std::endl;
}
~CTestDataBase()
{
std::cout<<"CloseDB!"<<std::endl;
}
};

2.      比较好的做法：

#include<stdexcept>
classCTestDataBase
{
public:
CTestDataBase()
{
ConnectDB();
}
~CTestDataBase()
{
if(!m_bClosed)// 双保险2
{
try
{
CloseDB();
}
catch(...)
{
std::cout<<"CloseDBerror"<<std::endl;
}
}
}
void ConnectDB()
{
std::cout<<"ConnectDB!"<<std::endl;
m_bClosed = false;
}
void CloseDB()//双保险1
{
std::cout<<"CloseDB!"<<std::endl;
m_bClosed = true;
}

private:
bool m_bClosed;
};
int main()
{
CTestDataBase a;
return 0;
}

 
条款9：绝不在构造函数和析构函数中调用virtual函数
注意点：逻辑本身不建议这么做。
例如：

#include <iostream>
#include <string>
#include <stdexcept>
class CBase
{
public:
CBase()
{
Log();
}
virtual void Log()
{
std::cout<<"Base Log"<<std::endl;
}
};
class CDerived:public CBase
{
public:
CDerived():CBase()
{
Log();
}
virtual void Log()
{
std::cout<<"Derived Log"<<std::endl;
}
};
int main()
{
CDerived a;
return 0;
}

执行结果：



如此运行了两次，如果非必要的话，请谨慎使用。
 
条款10：令operator= 返回一个reference to *this
注：此处的operator=泛指+=/ -= / *= / /= ..等等
原因：连续赋值。

#include <iostream>
#include <string>
#include <stdexcept>
class CTest
{
public:
void SetValue(int v)
{
val = v;
}
int GetValue() const
{
return val;
}
void ShowValue()
{
std::cout<<"val = "<<val<<std::endl;
}
CTest& operator=(const /*小心这里的const 只能调用const函数*/ CTest& other)
{
this->SetValue(other.GetValue());
return *this;
}

private:
int val;
};

int main()
{
CTest a,b,c;
a.SetValue(1);
b = c = a;
std::cout<<"a:";
a.ShowValue();
std::cout<<"b:";
b.ShowValue();
std::cout<<"c:";
c.ShowValue();
return 0;
}

条款11：小心在operator=中对自己赋值

处理办法1：对自我赋值进行检测
CTest& operator=(const CTest& other)
{
if(this == other)
return *this;
this->SetValue(other.GetValue());
return *this;
}

处理办法2(增加了对出现异常的处理)：

注：两种书写方式本质上是一样的，swap不必再区别2个对象是否还会存在不同。

//书写方式1
CTest& operator=(const CTest& other)
{
CTest other2(other); // 多构建一个副本
swap(other2);
return *this;
}
//书写方式2
CTest& operator=(CTest other)
{
swap(other);
return *this;
}

条款12：复制对象时请不要忘记任何一个成分
注意点：
这是个有意思的注意点：不要在派生类中的copyassignment 调用 copy 构造函数。因为那样的结果是不确定的，除非你自己很确定。

后记：三个默认函数就像三剑客一般，一般你需要重新定义其中一个，你就需要另外两个。