拷贝控制和资源管理
通常，管理类外资源的类必须定义拷贝控制成员。这种类需要通过析构函数释放对象分配的资源。一旦一个类需要析构函数，那几乎一定需要拷贝赋值运算符以及拷贝构造函数。
为了定义这些成员，首先必须确定该类型对象的拷贝语义，主要有两种选择：
- 定义拷贝操作
- 使类的行为像一个值或者指针
行为像一个值的类：应该有自己的状态。拷贝后副本和原对象完全独立，改变其中一个不影响另一个。
行为像一个指针的类：共享状态。拷贝该类型的对象，副本和原对象使用相同的底层数据，改变会影响另一个。
例如：string类行为像一个值；shared_ptr像一个指针；unique_ptr不许拷贝和赋值，因此不像值也不像指针。
示例：行为像值的类HasPtr
该类对象都要有自己的拷贝，包括：一个指向string的指针ps和一个int值i。因此，该类需要：
- 定义一个拷贝构造函数完成string的拷贝，而不是拷贝指针
- 定义一个析构函数释放该string
- 定义一个拷贝赋值运算符释放当前的string并从右侧运算对象拷贝string
#include <string>
#include <iostream>
class HasPtr{
public:
//默认使用string构造，包括未给出参数时，因此利用explicit防止隐式转换
explicit HasPtr(const std::string& s = std::string()): ps(new std::string(s)), i(0){
std::cout<<"default copy constructor launched"<<std::endl;
};
//同类拷贝构造函数
HasPtr(const HasPtr& hp): ps(new std::string(*hp.ps)), i(hp.i) {
std::cout<<"copy constructor of same class launched"<<std::endl;
};
HasPtr& operator=(const HasPtr& s);
~HasPtr(){
std::cout<<"dectructor launched"<<std::endl;
delete ps;
}
private:
int i;
std::string* ps;
};
HasPtr& HasPtr::operator=(const HasPtr &s) {
//创建临时变量这一步必须进行，防止直接删除ps的对象恰好就是s自己（为自己赋值的情况），从而无法正常分配内存
auto newp = new std::string(*s.ps);
delete ps;
ps = newp;
i = s.i;
std::cout<<"copy operator launched"<<std::endl;
return *this;
}
int main(){
std::string s = "string";
auto hp = HasPtr(s); //default copy constructor launched
HasPtr hp2; //default copy constructor launched
hp2 = hp; //copy operator launched
HasPtr hp3 = hp2; //copy constructor of same class launched
/*
dectructor launched
dectructor launched
dectructor launched
*/
}
注意赋值运算符中必须包含一个临时变量，已解决给自己赋值时提前释放自己的成员的错误。
示例：行为像指针的类HasPtr
行为类似指针的类，需要为其定义拷贝构造函数和拷贝赋值运算符来拷贝指针成员本身而不是其指向的string。
依然需要自己的析构函数来释放接受string参数的构造函数分配的内存。但是析构函数不能单方面释放关联的string，只有当最后一个指向string的HasPtr销毁时才可以释放string。
使一个类展现类似指针的行为，最好方法是使用shared_ptr进行管理。拷贝或赋值一个shared_ptr会拷贝或赋值其所指向的指针。同时，shared_ptr自己记录了引用计数。
引用计数的工作方式为：
- 除了初始化对象，每个构造函数都要创建一个引用计数；创建新对象时引用计数初始化为1；
- 拷贝构造函数不分配新的计数器，而是拷贝给定数据成员，包括计数器，但在拷贝后递增该共享的计数器，以指出该对象被新的对象共享；
- 析构函数递减计数器，指出少一个共享该对象的对象；同时，若计数器变为0则销毁该对象。
- 拷贝赋值运算符递增右侧对象计数器，递减左侧对象计数器。若左侧变为0则销毁。
问题在于存放引用计数的位置。计数器不能直接作为HasPtr对象的成员，因为：
HasPtr p1 = "000";
HasPtr p2(p1);
HasPtr p3(p1);
该代码中p2和p3不能正确共享引用计数。
解决该问题的一个方法是将计数器保存至动态内存，创建一个对象时分配一个新的计数器。当拷贝或赋值对象时拷贝指向计数器的指针，使得副本和原对象指向相同的计数器。
#include <iostream>
#include <string>
#include <memory>
class Printer;
class HasPtr{
public:
friend Printer;
//仅使用string初始化时重置引用计数为1
explicit HasPtr(const std::string& s = std::string()): ps(new std::string(s)), i(0), use(new std::size_t(1)) {
std::cout<<"default constructor launched"<<std::endl;
};
HasPtr(const HasPtr& hp): ps(new std::string(*hp.ps)), i(0), use(hp.use) {
++*use;
std::cout<<"constructor of same class launched"<<std::endl;
};
HasPtr& operator=(const HasPtr& hp);
~HasPtr();
private:
int i;
std::string* ps;
std::size_t* use; //引用计数
};
HasPtr& HasPtr::operator=(const HasPtr &hp) {
++*hp.use;
std::cout<<"copy operator launched"<<std::endl;
if (--*use == 0){
std::cout<<"use count 0, released by operator"<<std::endl;
delete ps;
delete use;
}
ps = hp.ps;
i = hp.i;
use = hp.use;
return *this;
}
HasPtr::~HasPtr() {
//保证每次调用析构函数都会令引用计数-1
if (--*use == 0){
std::cout<<"use count 0, released by destructor"<<std::endl;
delete ps;
delete use;
}
else std::cout<<"destructor launched but nothing deleted"<<std::endl;
}
class Printer{
public:
explicit Printer(HasPtr& hp): s(*hp.ps), i(hp.i){
this->u = *hp.use;
};
Printer() = delete;
[[noreturn]]void print_str() const{std::cout<<this->s<<std::endl;}
[[noreturn]]void print_int() const{std::cout<<this->i<<std::endl;}
[[noreturn]]void print_cnt() const{std::cout<<this->u<<std::endl;}
private:
std::string s;
int i;
size_t u;
};
int main(){
std::string s = "string";
auto hp = HasPtr(s); //default constructor launched
Printer(hp).print_cnt(); //1
HasPtr hp2; //default constructor launched
Printer(hp2).print_cnt(); //1，hp2的指针指向另一个地方
hp2 = hp; //copy operator launched，use count 0, released by operator
Printer(hp).print_cnt(); //2: 左-1归0释放，右+1, 左右指向同对象
HasPtr hp3 = hp2; //constructor of same class launched
Printer(hp2).print_cnt(); //3: 多了一个引用对象hp3
/*
destructor launched but nothing deleted //hp1
destructor launched but nothing deleted //hp2
use count 0, released by destructor //hp3: 程序结束后，先清理成员再析构
*/
}
