32）（典型）构造和析构拷贝构造小样例

 1 #include<iostream>
 2 using namespace std;
 3 class ABCD
 4 {
 5 public:
 6     ABCD(int a,int b,int c)
 7     {
 8         _a=a;
 9         _b=b;
10         _c=c;
11         cout<<"ABCD()的构造函数"<<"a:  "<<_a <<"b:  "<<_b <<"c:  "<<_c <<endl;    
12     }
13     ~ABCD()
14     {
15         cout<<"ABCD()的析构函数"<<endl;
16     
17     }
18     int get_a()
19     {
20         return  _a;
21     }
22 
23 
24 private:
25     int _a;
26     int _b;
27     int _c;
28 };
29 class MyE
30 {
31 public:
32     MyE():abcd1(1,2,3),abcd2(4,5,6),m(100)
33     {
34         cout<<"MyE()的构造函数"<<endl;
35     }
36     ~MyE()
37     {
38         cout<<"MYE()的析构函数"<<endl;
39     }
40     MyE(const MyE &another):abcd1(7,8,9),abcd2(10,11,12),m(100)
41     
42     {
43         cout<<"MyE的拷贝构造函数"<<endl;
44     }
45 
46 public:
47     ABCD abcd1;
48     ABCD abcd2;
49     int m;
50 
51 };
52 /**
53 因为这个mye1是一个普通的变量，所以，
54 也就是实参给形参赋值，也就有了调用MyE的拷贝构造函数
55 */
56 int doThing(MyE mye1)
57 {
58     cout<<"dothing()函数"<<endl;
59     cout<<mye1.abcd1.get_a()<<endl;
60     return 0;
61 }
62 int run()
63 {
64     MyE mye;
65     doThing(mye);
66     return 0;
67 }
68 int run2()
69 {
70     cout<<"run2函数开始了"<<endl;
71     ABCD(400,500,600);//临时对象的生命周期
72     cout<<"run2结束了"<<endl;
73     return 0;
74 }
75 int main()
76 {
77     run();
78     /**
79     ①首先调用MyE的无参构造函数，就是MyE():abcd1(1,2,3),abcd2(4,5,6),m(100)
80     ②然后运行那个doThing函数，将mye传进去了，（也就是实参给形参赋值嘛，所以，救调用MyE的拷贝构造函数。
81     ③
82     */
83     return 0;
84 }

结果截图：

然后，我调用那个 run2（）函数

 1 #include<iostream>
 2 using namespace std;
 3 class ABCD
 4 {
 5 public:
 6     ABCD(int a,int b,int c)
 7     {
 8         _a=a;
 9         _b=b;
10         _c=c;
11         cout<<"ABCD()的构造函数"<<"a:  "<<_a <<"b:  "<<_b <<"c:  "<<_c <<endl;    
12     }
13     ~ABCD()
14     {
15         cout<<"ABCD()的析构函数"<<endl;
16     
17     }
18     int get_a()
19     {
20         return  _a;
21     }
22 
23 
24 private:
25     int _a;
26     int _b;
27     int _c;
28 };
29 class MyE
30 {
31 public:
32     MyE():abcd1(1,2,3),abcd2(4,5,6),m(100)
33     {
34         cout<<"MyE()的构造函数"<<endl;
35     }
36     ~MyE()
37     {
38         cout<<"MYE()的析构函数"<<endl;
39     }
40     MyE(const MyE &another):abcd1(7,8,9),abcd2(10,11,12),m(100)
41     
42     {
43         cout<<"MyE的拷贝构造函数"<<endl;
44     }
45 
46 public:
47     ABCD abcd1;
48     ABCD abcd2;
49     int m;
50 
51 };
52 /**
53 因为这个mye1是一个普通的变量，所以，
54 也就是实参给形参赋值，也就有了调用MyE的拷贝构造函数
55 */
56 int doThing(MyE mye1)
57 {
58     cout<<"dothing()函数"<<endl;
59     cout<<mye1.abcd1.get_a()<<endl;
60     return 0;
61 }
62 int run()
63 {
64     MyE mye;
65     doThing(mye);
66     return 0;
67 }
68 int run2()
69 {
70     cout<<"run2函数开始了"<<endl;
71     ABCD(400,500,600);//临时对象的生命周期，也就是创建完后吗，就被析构了
72     cout<<"run2结束了"<<endl;
73     return 0;
74 }
75 int main()
76 {
77     //run();
78     /**
79     ①首先调用MyE的无参构造函数，就是MyE():abcd1(1,2,3),abcd2(4,5,6),m(100)
80     ②然后运行那个doThing函数，将mye传进去了，（也就是实参给形参赋值嘛，所以，救调用MyE的拷贝构造函数。
81     ③
82     */
83     run2();
84     return 0;
85 }

　　　　　　结果i就是：

3）然后还有一个代码：

 1 #include<iostream>
 2 using namespace std;
 3 class MyTest
 4 {
 5 public:
 6     MyTest(int a,int b,int c)
 7     {
 8         _a=a;
 9         _b=b;
10         _c=c;
11     }
12     MyTest(int a,int b)
13     {
14         _a=a;
15         _b=b;
16         MyTest(a,b,100);//产生了一个新的匿名对象(这里可以这么写，也就是产生一个对象，紧接着被析构了呗
17     }
18     ~MyTest()
19     {
20         cout<<"MyTest的析构函数开始啦    ----"<<_a<<" "<<_b<<" "<<_c<<endl;
21     }
22     int getC()
23     {
24         return _c;
25     }
26     void setC(int val)
27     {
28     _c=val;
29     }
30 private:
31     int _a;
32     int _b;
33     int _c;
34 
35 };
36 int main()
37 {
38     MyTest t1(1,2);
39     //t1.setC(100);
40     cout<<"MyTest的C数据   "<< t1.getC()<<endl;
41     return 0;
42 }

结果是：　　　　

　　　　　　在构造中调用构造是一个危险的行为

32）（典型）构造和析构 拷贝构造 小样例

32）（典型）构造和析构拷贝构造小样例