c++ primer 第十三章习题

练习13.1 拷贝构造函数是参数为同类对象引用其它参数都有默认值的构造函数。使用其它对象初始化新对象时使用。

练习13.2 应该使用引用参数，否则会陷入循环调用。

练习13.3 拷贝其中的资源与值   拷贝其中的指针对象

练习13.4 书上

练习13.5 

HasPtr(HasPtr& hp) {
   ps = new string(*hp.ps);
   i = hp.i;
}

练习13.6 =  同类对象赋值 每个非static元素相应赋值  未定义拷贝赋值运算符的时候

练习13.7 赋值对应的资源和对象   赋值对应对象

练习13.8 

HasPtr& operator=(const HasPtr& a) {
    ps = new string(*a.ps);
    i = a.i;
}

练习13.9 析构函数释放对象使用的资源并销毁对象的非static数据成员。合成析构函数释放类的成员对象。在用户未定义析构函数的时候会自动合成。

练习13.10 如果data计数减为0的时候释放资源。 销毁对象中的每个成员并且减计数。

练习13.11

~HasPtr() {
    delete ps;
}

练习13.12   3次

练习13.13

#include <iostream>
#include <string>
#include <vector>


using namespace std;

struct X
{
	int a;
	X() {
		a = 0;
		cout << "X()"<<endl;
	}
	X(const X& x) {
		a = x.a;
		cout << "X(const&)"<< a <<endl;
	}
	X& operator=(X& k) {
		a = k.a;
		cout <<"operator=(X& k)"<< a <<endl;
	}
	~X() {
		cout << "~X()"<< a <<endl;
	}
};

void print(X& a) {
	cout << "print(X&a)"<<endl;
}

void prints(X b) {
	cout << "print(X b)"<<endl;
}
int main() {
	X a;
	a.a = 4;
	X b(a);
	b.a = 5;
	X c = a;
	c.a = 7;
	print(a);
	prints(b);
	vector<X> v = {a,b,c};
	X* k = new X();
	delete k;

	return 0;
}

练习13.14 相同的内容

练习13.15 会  拷贝构造生成的对象序号不一样  三个不同的序号

练习13.16 没有拷贝构造函数就不会改变，如果接着上题的拷贝构造函数就会。

练习13.17

class numbered
{
public:
	int id;
	numbered(){id = rand()%100000;};
	numbered(numbered& a) {
		id = rand()%100000;
	}
	
};

// void f(numbered s) {
// 	cout << s.id << endl;
// }
void f(const numbered& s) {
	cout << s.id <<endl;
}
int main() {
	srand(time(0));
	numbered a, b = a, c = b;
	f(a);f(b);f(c);

	return 0;
}

练习13.18

class Employee
{
	int id;
	static int count;
	string name;
public:
	Employee(){id = count;};
	Employee(string& n) {
		count++;
		id = count;
		name = n;
	}
	~Employee(){};
	void print() {
		cout << id << ' '<< name<<endl;
	}
};
int Employee::count = 0;

int main() {
	string n("wang");
	Employee a(n), b(a);
	a.print();
	b.print();
	return 0;
}

练习13.19  不需要，直接进行默认拷贝即可。

练习13.21 不需要 直接每个默认复制即可

练习13.22

class HasPtr
{
	int i;
	string* ps;
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=(HasPtr&hp){
        auto news = new string(*hp.ps);
        delete ps;
		ps = news;
		i = hp.i;
		return *this;
	} 
	~HasPtr(){
		cout << *ps<<endl;
		delete ps;
	}
	
};

练习13.24 内存泄漏  多次析构统一指针的资源

练习13.25 智能指针能够自动析构

练习13.26

    StrBlob(StrBlob& a) {
    	data = make_shared<vector<string>>(new vector<string>(*a.data));
    }
    StrBlob& operator=(StrBlob& a) {
    	auto newData = make_shared<vector<string>>(new vector<string>(*a.data));
    	data = newData;
    }

练习13.27

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