第十三章 习题13-11-习题13-20

习题13-11

动态对象要用delete销毁

	~HasPtr()
	{
		delete ps;
	}

习题13-12

“当指向一个对象的引用或指针离开作用域时，析构函数不会执行”

三次；

这里由于执行的是拷贝初始化，不是拷贝赋值，而拷贝初始化的时候是引用传递，所以不会有函数传递产生的临时对象。

习题13-13

#include<iostream>
#include<vector>
using namespace std;
struct X {
	X() { cout << " X()" << endl; }
	X(const X&z) {  cout << "X(const X&)" << endl; }
	X &operator=(const X&z) {  cout << " X &operator=(const X&)" << endl; return *this; }
	~X() { cout << "~X()" << endl; }

};
void main()
{
	X X1;              //输出X()
	X X2(X1);          //输出X(const X&)
	X X3=X1;           //输出X(const X&)  拷贝初始化
	X X4;              //输出X()
	X4 = X1;           // X &operator=(const X&)拷贝赋值运算    
	vector<X> vec;
	vec.push_back(X1);       //输出X(const X&)  拷贝初始化，对函数push_back实参传递给形参   
	X *x = new X(X1);        //输出X(const X&)  拷贝初始化，对动态内存初始化函数传实参；    
	delete x;
}             
 销毁对象X1,X2,X3,X4,容器被销毁时执行析构函数，动态内存指针依靠delete析构；参见P445“什么时候会调用析构函数”

输出为：
 X()
X(const X&)
X(const X&)
 X()
 X &operator=(const X&)
X(const X&)
X(const X&)
~X()
~X()
~X()
~X()
~X()
~X()

习题13-14

输出3个完全一样的数，因为合成的拷贝构造函数会将每一个数据成员拷贝。

习题13-15

会，因为拷贝构造函数会阻止直接拷贝a中数据成员，而由拷贝构造函数控制怎么拷贝数据成员，即生成一个新的序号；新的结果是会输出3个不一样的数，并且这3个数不是abc中的数，因为在b、c初始化，以及实参a,b,c传递给形参的时候都发生了拷贝初始化；

习题13-16

会改变输出结果，因为a、b、c在调用函数f的时候，不使用拷贝初始化，所以最后的三个数就是a、b、c中的数；

习题13-17

#include <iostream>
using namespace std;
int sa = 10;
class numbered
{
public:
	numbered(){ mysn = sa++;}
	int mysn;
};
void f(numbered s)
{
	cout << s.mysn << endl;
}
void main()
{
	numbered a, b = a, c = b;
	f(a);
	f(b);
	f(c);
}
输出为 10,10,10；


#include <iostream>
using namespace std;
int sa = 10;
class numbered
{
public:
	numbered(){ mysn = sa++;}
	numbered(const numbered & s) { mysn = sa++; }
	numbered &operator=(const numbered&s) { mysn =sa++; return *this; }
	int mysn;
};
void f(numbered s)
{
	cout << s.mysn << endl;
}
void main()
{
	numbered a, b = a, c = b;
	f(a);
	f(b);
	f(c);
}
输出为：13,14,15

#include <iostream>
using namespace std;
int sa = 10;
class numbered
{
public:
	numbered(){ mysn = sa++;}
	numbered(const numbered & s) { mysn = sa++; }
	numbered &operator=(const numbered&s) { mysn =sa++; return *this; }
	int mysn;
};
void f(numbered &s)
{
	cout << s.mysn << endl;
}
void main()
{
	numbered a, b = a, c = b;
	f(a);
	f(b);
	f(c);
}
输出为：10,11,12；

习题13-18

struct Employee
{
	string name;
	int id;
	Employee() { id = s_id++; };
	Employee(string s) :name(s) { id = s_id++; };
	static int s_id;
};
int Employee::s_id = 0;

习题13-19

不需要，因为id不一样，

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

习题13-20

“因为这两个类中使用的是智能指针，因此在拷贝时，类的所有成员都将被拷贝，在销毁时所有成员也将被销毁。”