拷贝控制1(拷贝、赋值与销毁)

 1 #include <iostream>
 2 #include <vector>
 3 using namespace std;
 4 
 5 int main(void){
 6     vector<int> v1(10);//正确，直接初始化
 7     // vector<int> v2 = 10;//错误，接受大小参数的构造函数是 explicit
 8 
 9     void f(vector<int>);//f的形参进行拷贝初始化
10     // f(10);//错误，不能用一个explicit的构造函数拷贝一个实参
11     f(vector<int>(10));//正确，从一个int直接构造一个临时vector
12 
13     return 0;
14 }

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class gel{
 5 private:
 6     int x, y, z;
 7 
 8 public:
 9     gel(int a, int b, int c) : x(a), y(b), z(c) {cout << "111" << endl;}
10     gel(int a) : x(a), y(0), z(0) {cout << "222" << endl;}
11     gel(const gel& it) : x(it.x), y(it.y), z(it.z){cout << "333" << endl;}
12     ~gel(){cout << "444" << endl;}
13     
14 };
15 
16 int main(void){
17     // 编译器的思想是能不用临时对象就不用临时对象。因此对于下面这些拷贝初始化，
18     // 都不会生成临时对象再进行拷贝或移动到目标对象，而是直接通过函数匹配调用相应的构造函数。
19     gel a = 1;//拷贝初始化
20     //略过了拷贝构造函数，直接调用的gel(int a)构造函数，相当于gel a(1)；
21     
22     cout << "====" << endl;
23     gel b = gel(1, 2, 3);//相当于gel b(a, 2, 3)
24     cout << "----" << endl;
25 
26 // 输出：
27     // 222
28     // ====
29     // 111
30     // ----
31     // 444
32     // 444
33 
34     return 0;
35 }

 1 #include <iostream>
 2 #include <memory>
 3 using namespace std;
 4 
 5 class gel{
 6 public:
 7     gel(int a = 0, int *b = new int, shared_ptr<int> c = make_shared<int>()) :
 8         x(a), y(b), z(c) {}
 9     ~gel(){
10         //析构函数首先执行函数体,然后隐式地销毁成员
11         delete y;
12         //隐式销毁一个内置指针类型的成员不会delete其所指向的对象
13         //因此我们需要显式的用delete释放其所指向的内存,隐式销毁阶段时再自动销毁指针变量y本身
14         //x只是一个内置类型成员,会被自动隐式销毁
15         //z是一个智能指针成员,在销毁时会调用自己的析构函数,其所指对象在引用计数为0时自动释放
16     }
17 
18 private:
19     int x;
20     int *y;
21     shared_ptr<int> z;
22     
23 };
24 
25 int main(void){
26     gel *a(new gel);
27     delete a;
28 
29     return 0;
30 }

 1 #include <iostream>
 2 #include <memory>
 3 using namespace std;
 4 
 5 class gel{
 6 friend ostream& operator<<(ostream&, const gel&);
 7 
 8 private:
 9     int x, y;
10 
11 public:
12     gel(int a, int b) : x(a), y(a) {}
13     gel(int a) : gel(a, 0) {}
14     gel() : gel(0, 0) {}
15     ~gel() {
16         cout << "~gel" << endl;
17     }
18     
19 };
20 
21 ostream& operator<<(ostream &os, const gel &it){
22     cout << it.x << " " << it.y;
23     return os;
24 }
25 
26 void gg(gel *it){//it是指针变量，离开函数gg的作用域时不会调用析构函数
27 
28 }
29 
30 void yy(gel &it){//it是一个引用，离开函数yy的作用域时不会调用析构函数
31 
32 }
33 
34 int main(void){
35     gel a(1);
36     gg(&a);
37     cout << "===" << endl;
38 
39     gel *b = new gel(2);//b是指针变量，在离开main作用域时不会调用析构函数
40     gg(b);
41     cout << "---" << endl;
42 
43     yy(a);
44     cout << "///" << endl;
45 
46 
47 // 输出：
48     // ===
49     // ---
50     // ///
51     // ~gel
52 
53     //很显然只有变量a在离开main函数的作用域时调用了析构函数
54 
55     return 0;
56 }

 1 #include <iostream>
 2 using namespace std;
 3 
 4 struct NoCopy{
 5     NoCopy() = default;//使用合成默认构造函数
 6     NoCopy(const NoCopy&) = delete;//阻止拷贝
 7     NoCopy& operator=(const NoCopy&) = delete;//阻止赋值
 8     ~NoCopy() = default;//使用合成析构函数
 9 
10     //其它成员
11 };
12 
13 void f(int) = delete;//非成员函数也可以被定义成delete的
14 
15 int main(void){
16     
17 }

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class gel{
 5 private:
 6     int x;
 7 
 8 public:
 9     gel(int a) : x(a) {}
10     gel() = default;
11     ~gel() = delete;
12 };
13 
14 int main(void){
15     // gel a;//错误,不能创建该类变量
16     // gel(1);//错误,不能创建该类临时对象
17 
18     gel *b = new gel();//正确,可以分配该类型的对象
19     delete b;//错误,gel的析构函数是删除的
20 
21     return 0;
22 }