c++学习笔记十七

构造、析构、赋值运算


c++会为一个空类声明一个copy构造函数,一个copy assignment操作符和一个析构函数
如果没有声明构造函数，还会生成一个default构造函数


示例代码如下：
class Empty{...};
等同于
class Empty{
//default构造函数
Empty(){...}
//copy构造函数
Empty(const Empty& rhs){...}
//析构函数 non-virtual
~Empty(){...}
//copy assignment操作符
Empty& operator=(const Empty& rhs){...}
};






编译器会产生出
Empty el;//default构造函数


Empty e2(e1);//copy构造函数
e2=e1;//copy assignment操作符




copy构造函数和copy assignment操作符,编译器创建的版本只是单纯地将源对象的每一个
non-static成员变量拷贝到目标对象
示例代码如下：
template<typename T>
class NamedObject{
public:
//由于声明了构造函数,编译器不再生成default构造函数
NamedObject(const char* name,const T& value);
NamedObject(const std::string& name,const T& value);
...
private:
std::string nameValue;
T objectValue;
};
由于NamedObject函数没有声明copy构造函数和copy assignment操作符,编译器会自动创建
具体用法如下：
NamedObject<int> no1("Sample Prime Number",2);
//调用copy构造函数,以no1.nameValue和no1.objectValue为no2的两个属性符值
NamedObject<int> no2(no1);


copy assignment操作符
示例代码如下：
template<class T>
class NamedObject{
public:
NamedObject(std::string& name,const T& value);
...
private:
std::string& nameValue;
const T objectValue;
};


使用场景:
std::string newDog("persephone");
std::string oldDog("satch");
NamedObject<int> p(newDog,2);
NamedObject<int> s(oldDog,36);
p=s;




如果某对象是独一无二（不允许复制）,就需要拒绝编译器自动生成的函数
即将copy构造器和copy assignment操作符声明为private
即使这样member函数和friend函数还是会调用private函数,因此还要不去定义private函数
可以从标准程序库实现代码中查看如ios_base basic_ios和sentry


示例代码如下：
class HomeForSale{
public:
...
//copy构造函数和copy assignment操作符
private:
...
HomeForSale(const HomeForSale&);
HomeForSale& operator=(const HomeForSale&);
};
如果想拷贝HomeForSale对象编译器会阻止,如果是在member函数和friend函数中调用
连接器会阻止


如果想在编译时阻止,可以用以下方法实现
class Uncopyable{
protected:
Uncopyable(){}
~Uncopyable(){}
private:
Uncopyable(const Uncopyable&);
Uncopyable& operator=(const Uncopyable&);
};


//目标函数继承Uncopyable函数
//此时不用声明copy构造函数和copy assignment操作符
class HomeForSal: private Uncopyable{...};




为多态基类声明virtual析构函数
示例代码如下：
class TimeKeeper{
public:
Timekeeper();
~TimeKeeper();
...
};
class AtomicClock:public TimeKeeper{...}; //原子钟
class WaterClock:public TimeKeeper{...}; //水钟
class WristWatch:public TimeKeeper{...};//腕表


需要一个factory函数返回一个计时对象
TimeKeeper* getTimeKeeper();//返回一个指向TimeKeeper派生类的动态对象
Timekeeper* ptk=getTimeKeeper();
delete ptk;//释放资源


注：getTimeKeeper返回的指针指向一个derived class(派生类)对象，这个对象由一个
base class指针被删除,而base class（TimeKeeper）有个non-virtual析构函数,执行时
对象的derived部分没有被销毁(derived class的析构函数未执行)
解决办法如下：
class TimeKeeper{
public:
TimeKeeper();
virtual ~TimeKeeper();
...
};
TimeKeeper* ptk=getTimeKeeper();
delete ptk;


如果一个函数不打算用作base class时，就不需要使其构造函数为virtual


避免析构函数中报异常
示例代码如下：
class Widget{
public:
...
~Widget(){...}//假设这里出现异常
};
void doSomething(){
std::vector<widget> v;
...
} //v在这里被自动销毁




//联接数据库
class DBConnection{
public:
...
static DBConnection create(); //返回DBConnection对象
void close();
}


//用来管理DBConnection
class DBConn{
public:
...
//关闭联接
~DBConn(){
db.close();
}
private:
...
DBConnection db;
};
为了防止在DBConn的析构函数中调用close()方法发生异常
处理方法如下：
DBConn::~DBConn(){
try{db.close();}
catch(...){
//制作运转记录，记录对close的调用失败
std::abort();
}
}
//采用独立函数处理异常
class DBConn{
public:
...
void close(){
db.close();
closed=true;
}
~DBConn(){
if(!close){
try{
db.close();
}
catch(){
//制作运转记录，记录close调用失败
}
}
}
private:
DBConnection db;
bool closed;
}




不在构造函数和析构函数中调用virtual函数,回为这类调用从不下降至derived class
示例代码如下：


//所有交易的base class
class Tranxaction{
public:
Transaction();
//区分类型的目志记录
virtual void logTransaction() const=0;
...
};


//base class 实现
Transaction::Transaction(){
...
logTransaction();
}


//子类
class BuyTransaction:public Transaction{
public:
//日志记录此类型交易
virtual void logTransaction() const;
...
};
//子类
class SellTransaction:public Transaction{
public:
//日志记录此类型交易
virtual void logTransaction() const;
};


当执行BuyTransaction b;时首先Transaction构造函数会更早被调用
替换方法
class Transaction{
public:
explicit Transaction(const std::string& logInfo);
void logTransaction(const std::string& logInfo) const;//non_virtual函数
...
};
Transaction::Transaction(const std::string& logInfo){
...
logTransaction(logInfo);
}


class BuyTransaction:public Transaction{
public:
//将log信息传递给base class 构造函数
BuyTransaction(parameters):Transaction(createLogString(parameters)){...}
...
private:
static std::string createLogString(parameters);
};






让operator=返回一个reference to *this
赋值
int x,y,z;
x=y=z=15;
x=(y=(z=15));
示例代码如下：
class Widget{
public:
...
//返回类型是个reference,指向当前类型
Widget& operator+=(const Widget& rhs){
...
return *this;
}
Widget& operator=(int rhs){
...
return *this;
}
}


在operator=中处理"自我赋值"
//对象在赋值给自已时
class Widget{...};
Widget w;
...
w=w;




示例代码如下：
//保存一个指针指向一块动态分配的内存
class Bitmap{...};
class Widget{
...
private:
Bitmap* pb;
};
//operator=实现代码
Widget& widget::operator=(const Widget& rhs){
//如果是自我赋值就不作任何事
if(this==&rhs) return *this;

delete pb;
pb=new Bitmap(*rhs.pb);
return *this

//以上三行代码的异常处理
Bitmap* pOrig=pb;
pb=new Bitmap(*ths.pb);
delete pOrig;
return *this;
}




更好的实现，即处理异常安全，又处理自我赋值
class Widget{
...
void swap(Widget& rhs);//交换*this 和rhs的数据
};
Widget& Widget::operator=(const Widget& rhs){
Widget temp(rhs);
swap(temp);
return *this;
}




复制对象时注意其每一成员
示例代码如下：
void logCall(const std::string& funcName);
class Customer{
public:
...
Customer(const Customer& rhs);
Customer& operator=(const Customer& rhs);
...
private:
std::string name;
};




Customer::Customer(const Customer& rhs):name(rhs.name){//复制rhs的数据
logCall("Customer copy constructor");
}
Customer& Customer::operator=(const Customer& rhs){
logCall("Customer copy assignment operator");
name=rhs.name; //复制rhs数据
return *this;
}
当customer 中添加一个成员时,copy构造函数和copy assignment都要添加


如果是子类
PriorityCustomer:public Customer{
public:
...
PriorityCustomer(const PrivrityCustomer& rhs);
PriorityCustomer& operator=(const PriorityCustomer& rhs);
...
private:
int priority;
};


PriorityCustomer::PriorityCustomer(const PriorityCustomer& rhs)
:Customer(rhs), //调用base class 的copy构造函数
priority(rhs.priority){
logCall("PriorityCustomer copy constructor");
}
PriorityCustomer& PriorityCustomer::operator=(const PriorityCustomer& rhs){
logCall("PriorityCustomer copy assignment operator");
Customer::operator=(rhs);//对base class成分进行赋值动作
priority=rhs.priority;
return *this;
}