第十三章 拷贝控制

13.1

拷贝构造函数：这样的一个构造函数，第一个参数是自身类类型的引用，且任何额外参数都有默认值

使用拷贝初始化的情况：

• 用=定义变量
• 将一个对象作为实参传递给一个非引用类型的形参
• 从一个返回类型为非引用类型的函数返回一个对象
• 用花括号列表初始化一个数组中的元素或一个聚合类中的成员
• 某些类类型对它们所分配的对象使用拷贝初始化（如初始化标准库容器或调用其insert/push成员时）

13.2

这是类Sales_data的拷贝构造函数，我们在调用该拷贝构造函数来初始化类对象时，需要拷贝它的实参，但为了拷贝实参，我们又需要调用拷贝构造函数，如此无限循环。

举例：

当我们调用拷贝构造函数（即Sales_data(Sales_data rhs);）构建对象时，如：

    Sales_data s1;
    Sales_data s2(s1);    //死循环

代码首先使用s1作为实参构建rhs，然后为了构建形参rhs，使用传递给rhs的参数（s1）来构建rhs调用的构造函数的形参，然后为了构建.....

所以该函数一直在构建这个构造函数的形参，而始终都没有进入函数体

13.3

复制StrBlob时，其成员data关联的计数器会加1

复制StrBlobPtr时，由于成员是weak_ptr，弱指针复制不影响计数器

13.4

使用拷贝构造函数的地方：

Point global;  
Pint foo_bar(Point arg)			//1  arg  
{               				//2  local  
    Point local = arg, *heap = new Point(global);		//3  heap指向的对象  
    *heap = local;  
    Point pa[4]={ local, *heap };						//4 5  pa[0] pa[1]  
    return *heap;										//6  函数返回值  
}

 

13.5

class HasPtr  
{  
    string *ps;  
    int i;  
public:  
    HasPtr(const string &s = string()): ps(new string(s)), i(0)	{}
    //*的优先级低于.的优先级 
	HasPtr(HasPtr &hp) : ps(new string(*hp.ps)), i(hp.i)	{}   
};

 

13.6

拷贝赋值运算符：一个名为 operator= 的函数

什么时候使用：类对象与类对象之间的赋值时

合成拷贝赋值运算符完成的工作：将右侧运算对象的每个非static成员赋予左侧运算对象的对应成员

什么时候生成合成拷贝赋值运算符：该类未定义自己的拷贝赋值运算符时

13.7

所有成员的赋值会发生。两个StrBlob中智能指针所指对象内存相同，计数器加一；两个StrBlobPtr中弱指针所指对象内存相同，计数器不变。

13.8

class HasPtr  
{  
    string *ps;  
    int i;  
public:  
    HasPtr(const string &s = string()): ps(new string(s)), i(0)	{}
	HasPtr(HasPtr &hp) : ps(new string(*hp.ps)), i(hp.i)	{}   
	HasPtr& operator=(const HasPtr &hp)
	{
		delete ps;
		ps = new string(*hp.ps);
		i = hp.i;
		return *this;
	}
};

13.9

析构函数：是类的一个成员函数，函数名为~类名，没有返回值，也不接受参数

合成析构函数完成的工作：对于某些类，它被用来阻止该类型的对象被销毁；但更多的是用来释放对象使用的资源并销毁对象的非static成员

什么时候生成：该类未定义自己的析构函数时

13.10

调用StrBlob的合成析构函数释放数据成员，shared_ptr调用自己的析构函数，使计数-1

调用StrBlobPtr的合成析构函数，weak_ptr调用自己的析构函数，计数器不变

13.11

class HasPtr  
{  
    string *ps;  
    int i;  
public:  
    HasPtr(const string &s = string()): ps(new string(s)), i(0)	{}
	HasPtr(HasPtr &hp) : ps(new string(*hp.ps)), i(hp.i)	{}   
	HasPtr& operator=(const HasPtr &hp)
	{
		delete ps;
		ps = new string(*hp.ps);
		i = hp.i;
		return *this;
	}
	~HasPtr()
	{
		delete ps;	
	}
};

13.12

3次，形参accum，局部对象item1、item2在离开作用域后调用自己的析构函数

trans为指向一个对象的指针，其离开作用域时，析构函数不会执行

 

13.13

#include <iostream>
#include <fstream>
#include <sstream>
#include <iterator>
#include <initializer_list>
#include <vector> 
#include <string>
#include <cstring>
#include <deque>
#include <list> 
#include <forward_list>
#include <array>
#include <stack>
#include <queue>
#include <algorithm> 
#include <functional>
#include <map>
#include <set> 
#include <cctype>
#include <unordered_map>
#include <unordered_set>
#include <memory> 
#include <new> 
 
using namespace std;
using namespace std::placeholders;

struct X{
    X() { cout << "X()" << endl; }
    X(const X &x) {    cout << "X(const X &x)" << endl; }
    X& operator=(const X &x)
    {
        cout << "operator=(const X &x)" << endl;
        return *this;
    }
    ~X(){ cout << "~x()" << endl; } 
};

int main()
{
    //默认构造函数 
    X x1;
    X *p = new X();
    //拷贝构造函数 
    X x2(x1);
    X x3 = x1;
    X *q = new X(x1); 
    //拷贝赋值运算符 
    x3 = x2;
    //析构函数 
    delete p;
    delete q;
    return 0;
}

13.14

输出三个相同的序号

因为合成的拷贝构造函数只是将参数的成员逐个拷贝到正在创建的对象中，所以三个对象的mysn成员的值都相同

13.15

会改变，因为numbered类有自己的拷贝构造函数，而这个拷贝构造函数能生成一个新的序号。

所以，执行numbered b = a时，会调用拷贝构造函数，创建对象b；创建对象c也是如此。

新的输出结果是：三个不同的序号

补充：执行f(a)时，也会执行拷贝构造函数。

13.16

结果不变，因为传递的参数是常量引用，仍然会得到该实参对象的mysn值

结果会变，因为实参变为常量引用类型，故调用f()时无需拷贝，那么拷贝构造函数也不会执行。

新的输出结果是：三个不同的序号

13.17

#include <iostream>
#include <fstream>
#include <sstream>
#include <iterator>
#include <initializer_list>
#include <vector> 
#include <string>
#include <cstring>
#include <deque>
#include <list> 
#include <forward_list>
#include <array>
#include <stack>
#include <queue>
#include <algorithm> 
#include <functional>
#include <map>
#include <set> 
#include <cctype>
#include <unordered_map>
#include <unordered_set>
#include <memory> 
#include <new> 
 
using namespace std;
using namespace std::placeholders;

class numbered{
    friend void f(numbered);
    int mysn;
public:
    numbered()
    {
        static int val = 0;
        ++val;
        mysn = val;
    }
    numbered(numbered &num){ mysn = num.mysn + 5; }
}; 

void f(numbered s)
{
    cout << s.mysn << endl;
}

int main()
{
    numbered a, b = a, c = b;
    f(a);
    f(b);
    f(c);
    return 0;
}

    

13.18

class Employee{
	static size_t val;　　//static静态成员数据在类内声明，但只可以在类外定义，在类外定义时可不加static
	string name;
	size_t num;
public:
	Employee()
	{
		num = ++val;
	}
	Employee(string s): name(s)
	{
		num = ++val;
	}
};

13.19

不需要，因为没有两个雇员的姓名和雇员证号相同。

	Employee(const Employee &) = delete;
	Employee& operator=(const Employee &) = delete;

13.21

知识点：判断一个类是否需要拷贝控制函数成员，首先判断其是否需要自定义版本的析构函数，如果需要，则拷贝控制成员函数都需要。

不需要，因为这两个类中的指针为智能指针，可以自动控制内存的释放，所以使用类的合成析构函数即可。

13.22

class Hasptr  
{  
public:  
	//默认构造函数
    Hasptr(const string &s = string()): ps(new string(s)), i(0) {} 
    //拷贝构造函数，完成string 指针指向内容的拷贝和i值的拷贝  
    Hasptr(const Hasptr &hp): ps(new string(*hp.ps)),i(hp.i) {}    
    //拷贝赋值运算符  
    Hasptr& operator=(const Hasptr &p)
    { 
    	//防止p和*this是同一个对象 
    	auto newp = new string(*p.ps);
        delete ps; 
		ps = newp;
		i = p.i;  
        return *this;  
    }   
    //析构函数  
    ~Hasptr(){ delete ps; }  
private:  
    string *ps;  
    int i;  
};

13.23

默认构造函数也是要创建一个动态内存对象的

防范自赋值操作

13.24

未定义析构函数：会使ps指向的内存无法释放，造成内存泄漏

未定义拷贝构造函数：拷贝数据成员ps，只会拷贝指针本身

13.25

因为希望是StrBlob的类值版本，所以涉及动态分配内存。

拷贝构造函数和拷贝赋值运算符：为调用对象动态分配内存，而不是与实参共享内存

动态分配的内存由shared_ptr管理，其析构函数会自动判断进行释放，所以不需要自定义版本的析构函数。

13.26

class StrBlob {
public:
	using size_type = vector<string>::size_type;
	StrBlob();
	StrBlob(initializer_list<string> il);
	//13.26
	StrBlob(const StrBlob&); 
	StrBlob& operator=(const StrBlob&);
	//over
	size_type size() const { return data->size(); }
	bool empty() const { return data->empty(); }
	void push_back(const string &s);
	void pop_back();
	string& front();
	string& back();
	const string& front() const;
	const string& back() const;
	StrBlobPtr begin();
	StrBlobPtr end();
private:
	shared_ptr<vector<string>> data;
	void check(size_type i, const string &msg) const; 
}; 

//StrBlob::StrBlob(const StrBlob &rhs): data(make_shared<vector<string>>(*rhs.data))
StrBlob::StrBlob(const StrBlob &rhs): data(new vector<string>(*rhs.data))	//也可以像上面那样 
{
}

StrBlob& StrBlob::operator=(const StrBlob &rhs)
{
	data = make_shared<vector<string>>(*rhs.data);
	return *this;
}

13.27

class HasPtr  
{  
public:  
	//默认构造函数
    HasPtr(const string &s = string()): ps(new string(s)), i(0), use(new size_t(1)) {} 
    //拷贝构造函数，完成string 指针指向内容的拷贝和i值的拷贝  
    HasPtr(const HasPtr &hp): ps(hp.ps), i(hp.i), use(hp.use) { ++*use; }    
    //拷贝赋值运算符  
    HasPtr& operator=(const HasPtr &);  
    //析构函数  
    ~HasPtr(); 
private:  
    string *ps;  
    int i;  
    size_t *use; 
};

HasPtr& HasPtr::operator=(const HasPtr &p)
{
	++*p.use;
	if(--*use == 0) {
		delete ps;
		delete use;
	}
	ps = p.ps;
	i = p.i;
	use = p.use;
	return *this;
}

HasPtr::~HasPtr()
{
	if(--*use == 0) {
		delete ps;
		delete use;
	}
}

13.29

inline void swap(HasPtr &lhs, HasPtr &rhs)
{
	using std::swap;
	swap(lhs.ps, rhs.ps);	//交换指针，而不是string数据 
	swap(lhs.i, rhs.i);		//交换int成员 
} 

如果存在类型特定的swap版本，swap调用会与之匹配；如果不存在，则会使用std中的版本。

此swap()函数体中的swap()函数并不会递归调用自身，而是调用标准库中的swap()函数。

13.30

class Hasptr  
{  
public:
    Hasptr(const string &s = string()): ps(new string(s)), i(0) {} 
    Hasptr(const Hasptr &hp): ps(new string(*hp.ps)),i(hp.i) {} 
    /*   
    Hasptr& operator=(const Hasptr &p)
    { 
        //防止p和*this是同一个对象 
        auto newp = new string(*p.ps);
        delete ps; 
        ps = newp;
        i = p.i;  
        return *this;  
    }   */
    ~Hasptr(){ delete ps; } 
    //13.30
    friend void swap(Hasptr &, Hasptr &); 
    Hasptr& operator=(Hasptr p)        //此处调用拷贝构造函数会分配空间 
    { 
        swap(*this, p);
        return *this;  
    } 
private:  
    string *ps;  
    int i;  
};

inline void swap(Hasptr &hp1, Hasptr &hp2)
{
    cout << "swap() function is being used. 
";
    swap(hp1.ps, hp2.ps);
    swap(hp1.i, hp2.i);
}

int main()
{
    Hasptr hp1("kzw"), hp2, hp3;
    swap(hp1, hp2);
    hp3 = hp2;
    return 0;
}

13.31

#include <iostream>
#include <vector> 
#include <string>
#include <algorithm> 
#include <new> 
 
using namespace std;

class Hasptr  
{
    friend void swap(Hasptr&, Hasptr&); 
    friend ostream& operator<<(ostream &os, const Hasptr &hp); 
public:
    Hasptr(const string &s = string()): ps(new string(s)), i(0) {} 
    Hasptr(const Hasptr &hp): ps(new string(*hp.ps)),i(hp.i) {} 
    ~Hasptr(){ delete ps; }  
    Hasptr& operator=(Hasptr p)
    { 
        swap(*this, p);
        return *this;  
    } 
    bool operator<(const Hasptr &rhs) const
    {
        return *ps < *rhs.ps;
    } 
private:  
    string *ps;  
    int i;  
};

inline void swap(Hasptr &hp1, Hasptr &hp2)
{
    cout << "swap() function is being used. 
";
    swap(hp1.ps, hp2.ps);
    swap(hp1.i, hp2.i);
}

ostream& operator<<(ostream &os, const Hasptr &hp)
{
    os << *hp.ps;
    return os;
}

int main()
{
    Hasptr hp1("kzw"), hp2("ly"), hp3("8023");
    vector<Hasptr> vec{hp1, hp2, hp3};
    sort(vec.begin(), vec.end());        //排序赋值时会用到swap函数 
    for (auto &i : vec) 
        cout << i << " ";                //输出8023 kzw ly
    cout << endl;
    return 0;
}

13.32

会，swap函数隐式地进行引用计数的增减，而且减少了我们自己对内存进行分配的操作

下面这段代码，在形参部分会利用拷贝构造函数递增*use，而函数结束会利用析构函数递减*use：

//相较于书中冗余的代码，这更简洁
HasPtr &operator=(HasPtr hp)  
{  
    swap(*this, hp);  
    return *this;  
}  

13.33

传引用：避免了传值的拷贝操作，可以修改形参绑定的对象

不用const：函数要修改形参绑定的对象

13.34

class Message{
    friend class Folder;
public:
    explicit Message(const string &str = ""): contents(str) {}
    Message(const Message&);
    Message& operator=(const Message&);
    ~Message();
    void save(Folder&);
    void remove(Folder&);
private:
    string contents;
    set<Folder*> folders;
    void add_to_Folders(const Message&);
    void remove_from_Folders();
};

void Message::add_to_Folders(const Message &m)
{
    for (auto f : m.folders)
        f->addMsg(this);
}

void Message::remove_from_Folders()
{
    for (auto f : m.folders)
        f->remMsg(this);
}

Message::Message(const Message &m): contents(m.contents), folers(m.folders)
{
    add_to_Folders(m);
}

Message::~Message()
{
    remove_from_Folders();
}

Message& Message::operator=(const Message &rhs)
{
    remove_from_Folders();
    contents = rhs.contents;
    folders = rhs.folders;
    add_to_Folders(rhs);
    return *this;
}

void Message::save(Folder &f)
{
    folders.insert(&f);
    f.addMsg(this);
} 

void Message::remove(Folder &f)
{
    folders.erase(&f);
    f.remMsg(this);
}

13.35

使用合成拷贝控制成员：拷贝构造函数不会把信息添加到Folder中；拷贝赋值运算符不会更新Folder，也不会将新信息添加到Folder中；析构函数没有清空保留在Folder中的数据

13.36

class Folder{
public:
	//下面四个拷贝控制成员都可以省略，它们和对应的合成版本的功能相同 
	Folder();
	~Folder();
	Folder(const Folder&);
	Folder& operator=(const Folder&); 
	//添加/删除给定Message的指针 
	void addMsg(Message*);
	void remMsg(Message*);
private:
	set<Message*> msg;
};

//Folder类定义 
void Folder::addMsg(Message *m)
{
	msg.insert(m);
}

void Folder::remMsg(Message *m)
{
	msg.erase(m);
}

13.37

void Message::addFold(Folder *f)
{
	folders.insert(f);
}

void Message::remFold(Folder *f)
{
	folders.erase(f);
}

13.38

当涉及到动态分配内存时，拷贝并交换是一个完成该功能的精简的方式。本题中并未涉及动态分配内存。

13.39

#include <iostream>
#include <fstream>
#include <sstream>
#include <iterator>
#include <initializer_list>
#include <vector> 
#include <string>
#include <cstring>
#include <deque>
#include <list> 
#include <forward_list>
#include <array>
#include <stack>
#include <queue>
#include <algorithm> 
#include <functional>
#include <map>
#include <set> 
#include <cctype>
#include <unordered_map>
#include <unordered_set>
#include <memory> 
#include <new> 
#include <utility>
 
using namespace std;
using namespace std::placeholders;

class StrVec {
public:
    StrVec(): elements(nullptr), first_free(nullptr), cap(nullptr) {}
    StrVec(const StrVec&);
    StrVec &operator=(const StrVec&);
    ~StrVec();
    void push_back(const string&);
    size_t size() const { return first_free - elements; }
    size_t capacity() const { return cap - elements; }
    string *begin() const { return elements; }
    string *end() const { return first_free; }
    void reallocate_my(size_t newcapacity);
    void reserve(size_t n);
    void resize(size_t n);
private:
    allocator<string> alloc;
    void chk_n_alloc()
    {
        if (size() == capacity())
            reallocate();
    }
    pair<string*, string*> alloc_n_copy(const string*, const string*);
    void free();
    void reallocate();
    string *elements;
    string *first_free;
    string *cap;
};

void StrVec::push_back(const string &s)
{
    chk_n_alloc();
    alloc.construct(first_free++, s);
}

pair<string*, string*> StrVec::alloc_n_copy(const string *b, const string *e)
{
    auto data = alloc.allocate(e - b);
    return {data, uninitialized_copy(b, e, data)};
}

void StrVec::free()
{
    if (elements) {
        for (auto p = first_free; p != elements;)
            alloc.destroy(--p);
        alloc.deallocate(elements, cap - elements);
    }
}

StrVec::StrVec(const StrVec &s)
{
    auto newdata = alloc_n_copy(s.begin(), s.end());
    elements = newdata.first;
    first_free = cap = newdata.second;
}

StrVec::~StrVec()
{
    free();
}

StrVec &StrVec::operator=(const StrVec &rhs)
{
    auto data = alloc_n_copy(rhs.begin(), rhs.end());
    free();
    elements = data.first;
    first_free = cap = data.second;
    return *this;
}

void StrVec::reallocate()
{
    auto newcapacity = size() ? 2 * size() : 1;
    auto newdata = alloc.allocate(newcapacity);
    auto dest = newdata;
    auto elem = elements;
    for (size_t i = 0; i != size(); ++i)
        alloc.construct(dest++, move(*elem++));
    free();
    elements = newdata;
    first_free = dest;
    cap = elements + newcapacity;
}

void StrVec::reallocate_my(size_t newcapacity)
{
    auto newdata = alloc.allocate(newcapacity);
    auto dest = newdata;
    auto elem = elements;
    for (size_t i = 0; i != size(); ++i)
        alloc.construct(dest++, move(*elem++));  
    free();  
    elements = newdata;  
    first_free = dest;  
    cap = elements + newcapacity;  
}

void StrVec::reserve(size_t n)
{
    if (n > capacity())
        reallocate_my(n);
}

void StrVec::resize(size_t n)
{
    if (n > size()) {
        if (n > capacity())
            reserve(2 * n);
        for (size_t i = size(); i != n; ++i)
            alloc.construct(first_free++);        //构造空串 
    }
    else {
        while (first_free != elements + n) {
            alloc.destroy(--first_free);
        }
    }
}

int main()
{
    return 0;
}

13.40

StrVec::StrVec(initializer_list<string> il)
{
	auto newdata = alloc_n_copy(il.begin(), il.end());
	elements = newdata.first;
	cap = first_free = newdata.second;
}

13.41

first_free指向的是一个空位置，前置的话会跳过一个空位置。

13.43

for_each(elements, first_free, [this](string &rhs){ alloc.destroy(&rhs); });

两种实现各有千秋，我都喜欢

13.44

class String {
	friend ostream &operator<<(ostream &os, const String &s); 
public:
	String(): elements(nullptr), first_free(nullptr), cap(nullptr) {}  
	String(const char*);
	String(const String&);
	String& operator=(const String&);
	~String(){ free(); }
	size_t size()const{return first_free-elements;}     //返回已占用的大小  
    size_t capacity()const{return cap-elements;}    //返回总大小  
    char *begin()const{return elements;}  
    char *end()const{return first_free;}   
    String &operator=(const String&);  
    String &operator=(const char*); 
private:
	allocator<char> alloc;
	void chk_n_alloc()
	{
		if (size() == capacity())
			reallocate();
	}
	pair<char*, char*> alloc_n_copy(const char*, const char*);
	void free();
	void reallocate();
	string *elements;
	string *first_free;
	string *cap;
};

 

13.45

右值引用：绑定到右值的引用，通过&&来获得右值引用，只能绑定到一个将要销毁的对象

左值引用：绑定到左值的引用，通过&来获得左值引用

13.46

知识点：

右值引用可以绑定到这类表达式：要求转换的表达式、字面常量、返回右值的表达式（返回非引用类型的函数，算术、关系、位以及后置递增/递减运算符）

左值引用可以绑定到这类表达式：返回左值的表达式（返回左值引用的函数，赋值、下标、解引用以及前置递增/递减运算符）

变量是左值，故不能将一个右值引用绑定到一个变量上，即使这个变量是右值引用类型

	int &&r1 = f();
	int &r2 = vi[0];
	int &r3 = r1;　　　　　　　　 //r1是变量
	int &&r4 = vi[0] * f(); 　　//右侧是算术表达式

13.49

    StrVec(StrVec &&s);
    StrVec &operator=(StrVec &&s);
    String(String &&s);  
    String &operator=(String &&s);
    Message(Message &&m);
    Message &operator=(Message &&m);

13.50

返回左值时会避免拷贝

13.51

因为将要被销毁，智能指针离开作用域后销毁，而返回值返回后也会销毁

调用clone返回的是一个右值，所以赋值时会用移动操作而不是拷贝

13.52

调用拷贝构造rhs、把rhs与调用对象执行swap交换、返回后rhs被销毁

13.53

参数为右值，交换不必要

13.54

当使用h1=std:move(h2);时有多个运算符“=”匹配，除非拷贝赋值运算符是const &

13.55

void StrBlob::push_back(string &&s)
{
	data->push_back(std::move(s));
}

13.56

ret是左值，当返回ret.sorted()时，调用的是Foo Foo::sorted() const &;，而不是Foo Foo::sorted() &&;，所以会进入死循环，导致堆栈溢出

13.57

拷贝构造一个临时对象，调用sorted()&&，返回时调用移动构造函数Foo Foo::sorted() &&;

13.58

#include <iostream>
#include <fstream>
#include <sstream>
#include <iterator>
#include <initializer_list>
#include <vector> 
#include <string>
#include <cstring>
#include <deque>
#include <list> 
#include <forward_list>
#include <array>
#include <stack>
#include <queue>
#include <algorithm> 
#include <functional>
#include <map>
#include <set> 
#include <cctype>
#include <unordered_map>
#include <unordered_set>
#include <memory> 
#include <new> 
#include <utility>
 
using namespace std;
using namespace std::placeholders;

class Foo  
{  
public:  
    Foo sorted() && ;  
    Foo sorted() const &;  
private:  
	vector<int> data;  
};  

Foo Foo::sorted() &&  
{  
    cout << "&&" << endl;  
    sort(data.begin(), data.end());  
    return *this;  
}  

Foo Foo::sorted() const &  
{  
    cout << "const &" << endl;  
    Foo ret(*this);  
    return ret.sorted(); 	//函数将导致运行时堆栈溢出  
}  
  
int main()  
{  
    using namespace std;  
    Foo f;  
    f.sorted(); 			//无限递归  
    std::move(f).sorted();  //调用sorted()&&  
    return 0;  
}