13.2拷贝控制和资源管理
练习
13.22
这个练习是错误的示范，正确的示范在练习13.23中
class HasPtr {
public:
HasPtr(const std::string& s = std::string()) :ps(new std::string(s)), i(0) {};
HasPtr(const HasPtr& hasptr) :ps(new string(*hasptr.ps)), i(hasptr.i) {
};
//列表初始化只能在构造函数中使用
HasPtr& operator=(const HasPtr& p) {
ps = new string(*p.ps);
i = p.i;
};
~HasPtr() {
delete ps;
}
private:
std::string *ps;
int i;
};
13.2.1 行为像值的类
想要将类的行为定义的像一个值，就必须在赋值拷贝时，对象和对象之间的数据成员相互独立，互不影响。
对于包含了内置指针数据成员的类想要实现类值行为。
在指向拷贝赋值运算符时，需要考虑到此时的拷贝赋值运算符像是构造函数和析构函数的整合，一方面需要将内置指针所指向的对象销毁，一方面需要为其赋值。
最安全的写法是：首先将形参中的指针数据成员所指向的对象拷贝一份，创建临时变量。
然后删除本对象的指针所指向的对象。
最后将临时对象赋值给指针。
不要先delete 指针，因为如果传入的对象和左侧运算对象是一个对象，那么先delete，再调用解引用，将产生未定义的行为。
练习
13.23
显然，我写的代码和书上的代码差距很大。问题出现在重载赋值运算符上。
首先我没有考虑赋值时，ps原来指向的对象需要删除。
于是，我写了这样的版本：
HasPtr& operator=(const HasPtr& p) {
delete ps;
ps = new string(*p.ps);
i = p.i;
return *this;
};
在VS2017下，重载赋值运算符没有返回值也没有报错。。
上面的代码又有一个问题，如果赋值运算符右侧的运算对象和左侧的运算对象是一个对象，那么delete ps。将导致*p.p产生未定义的行为。
因此下面的版本才是一个正确的版本。首先将本对象中要销毁的数据成员用临时变量保存p中相同的成员。
然后再delete需要销毁的对象，然后再将临时变量的值赋给数据成员。
HasPtr& operator=(const HasPtr& p) {
auto temp = new string(*p.ps);
delete ps;
ps = temp;
i = p.i;
return *this;
};
13.24
没有定义析构函数，将导致内存泄漏
没有定义拷贝构造函数将导致，再拷贝初始化时，两个对象的数据成员ps指向同一个对象。如果其中一个对象被销毁，另一个对象的ps指向了一个被收回的空间。
13.25
如果需要继续使用shared_ptr又要StrBlob变成类值的版本。
那么在拷贝构造函数中，需要为
std::shared_ptr<vector<string>> data;
数据成员使用make_shared创建对象。
而在拷贝赋值运算符中，不需要先删除之前所指向的对象，直接调用make_shared（）即可，因为智能指针内部有引用计数，当前指针被赋值一个新值，过去的对象的引用计数-1，如果为0则释放并销毁对象。
因为是智能指针对象，可以自行维护保存的对象，所以不需要析构函数。
13.26
class StrBlobPtr;
class ConstStrBlobPtr;
class StrBlob {
friend class StrBlobPtr;
friend class ConstStrBlobPtr;
public:
using size_type = vector<string>::size_type;
StrBlob();
StrBlob(std::initializer_list<std::string> il);
size_type size() const { return data->size(); };
bool empty() const { return data->empty(); };
void push_back(const string& str) { data->push_back(str); };
void pop_back();
std::string& front();
const std::string& front()const;
std::string& back();
const std::string& back() const;
StrBlob(const StrBlob& b) :data(std::make_shared<vector<string>>(*b.data)) {
};
StrBlob& operator=(const StrBlob& d) {
auto temp = std::make_shared<vector<string>>(*d.data);
data = temp;
return *this;
};
StrBlobPtr begin();
StrBlobPtr end();
ConstStrBlobPtr begin()const;
ConstStrBlobPtr end()const;
//private:
std::shared_ptr<vector<string>> data;
void check(size_type i, const string& msg) const;
};
StrBlob::StrBlob() :data(std::make_shared<vector<string>>()) {
}
StrBlob::StrBlob(std::initializer_list<string> il) : data(std::make_shared<vector<string>>(il)) {
}
测试代码
StrBlob b({ "123","234" });
StrBlob b1 = b;
b1.push_back("233");
for (const auto& item:*b.data) {
cout << item << endl;
}
StrBlob b2;
b2 = b1;
b2.push_back("666");
for (const auto& item : *b1.data) {
cout << item << endl;
}
13.2.2 行为像指针的类
想要定义行为像指针的类，我们可以使用shared_ptr来实现，或者使用引用计数的思想。
在类中定义一个变量，这个变量指向一块动态分配的内存，同于计数。
在赋值运算符的函数体中，++右侧运算对象计数器，–左侧运算对象计数器。如果左侧对象计数器为0，则删除指针指向的内存。
对于析构函数则先–计数器，然后判断计数器是否为0，为0则回收内存。
练习
13.28
class HasPtr {
public:
HasPtr(const std::string& s = std::string()) :ps(new std::string(s)), i(0),ref_count(new size_t(1)) {};
HasPtr(const HasPtr& hasptr) :ps(hasptr.ps), i(hasptr.i),ref_count(hasptr.ref_count) {
++(*ref_count);
};
//列表初始化只能在构造函数中使用
HasPtr& operator=(const HasPtr& p) {
++*p.ref_count;
if (--*ref_count==0) {
delete ps;
delete ref_count;
}
ps = p.ps;
ref_count = p.ref_count;
i = p.i;
return *this;
};
~HasPtr() {
if (--*ref_count==0) {
delete ps;
delete ref_count;
}
}
private:
std::string *ps;
int i;
size_t* ref_count;
};
13.28
这里使用类值的方式对两个类添加的控制成员。
这样我们就不必管外部传入的对象是否是动态创建的。
class TreeNode {
public:
TreeNode(const string& str, int c, TreeNode* l=nullptr, TreeNode* r=nullptr):value(str),count(c){
if (l!=nullptr) {
left = new TreeNode(*l);
}
if (r!=nullptr) {
right = new TreeNode(*r);
}
};
TreeNode(const TreeNode& t) :value(t.value),count(t.count){
if (t.left!=nullptr) {
left = new TreeNode(*t.left);
}
if (t.right!=nullptr) {
right = new TreeNode(*t.right);
}
};
TreeNode& operator=(const TreeNode& t) {
TreeNode * l_temp = nullptr;
if (t.left!=nullptr) {
l_temp = new TreeNode(*t.left);
}
TreeNode* r_temp = nullptr;
if (t.right!=nullptr) {
r_temp = new TreeNode(*t.right);
}
left = l_temp;
right = r_temp;
value = t.value;
count = t.count;
return *this;
};
~TreeNode() {
cout<<"~TreeNode"<<endl;
delete left;
delete right;
}
private:
string value;
int count;
TreeNode *left;
TreeNode *right;
};
class BinStrTree {
public:
BinStrTree(TreeNode* r) {
if (r!=nullptr) {
root = new TreeNode(*r);
}
};
BinStrTree(const TreeNode& t) {
root = new TreeNode(t);
}
BinStrTree& operator = (const BinStrTree& t) {
//如果保存一份副本可能代价很大，所以直接判断，两个对象里面的root指针是否相等
if (root!=t.root) {
delete root;
}
root = new TreeNode(*t.root);
return *this;
}
~BinStrTree() {
delete root;
}
private:
TreeNode *root;
};
