C++面向对象

一、了解c++类各成员函数的关系

写出下面代码的输出结果

[cpp]  view plain  copy

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class A  
6. {  
7.     int num;  
8. public:  
9.     A()  
10.     {  
11.         cout<<"Default constructor"<<endl;  
12.     }  
13.     ~A()  
14.     {  
15.         cout<<"Desconstructor"<<endl;  
16.         cout<<num<<endl;  
17.     }  
18.     A(const A& a)  
19.     {  
20.         cout<<"Copy constructor"<<endl;  
21.     }  
22.     void operator=(const A& a)  
23.     {  
24.         cout<<"Overload operator"<<endl;  
25.     }  
26.     void setnum(int n)  
27.     {  
28.         num = n;  
29.     }  
30. };  
31.   
32. int main()  
33. {  
34.     A a1;  
35.     A a2(a1);  
36.     A a3=a1;  
37.     A &a4=a1;  
38.     a1.setnum(1);  
39.     a2.setnum(2);  
40.     a3.setnum(3);  
41.     a4.setnum(4);  
42.   
43.     return 0;  
44. }  

代码第34行，定义了一个对象a1，调用的是默认的构造函数。

代码第35行，用a1初始化一个对象a2，调用的是复制构造函数。

代码第36行，同上。注意，这里不是调用赋值函数，这里属于对象a3的初始化，而不是赋值。若要调用赋值，必须为如下形式。

[html]  view plain  copy

1. A a3;  
2. a3 = a1;  

代码第37行，定义a4为a1的一个引用，不调用构造函数或赋值函数。

代码第38~41行，调用各个对象的setnum()成员函数为私有成员num赋值。这里注意，由于a4为a1的引用，因此a4.setnum实际上和a1.setnum一样。

当main函数退出时，对象析构顺序与调用构造函数顺序相反，依次为a3，a2，a1.

输出：

[cpp]  view plain  copy

1. Default constructor  
2. Copy constructor  
3. Copy constructor  
4. Desconstructor  
5. 3  
6. Desconstructor  
7. 2  
8. Desconstructor  
9. 4  

二、c++类的临时对象

已知class B以及Play()函数定义如下。

[cpp]  view plain  copy

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class B  
6. {  
7.     int data;  
8. public:  
9.     B()  
10.     {  
11.         cout<<"default constructor"<<endl;  
12.     }  
13.     ~B()  
14.     {  
15.         cout<<"destructed"<<endl;  
16.     }  
17.     B(int i) : data(i)  
18.     {  
19.         cout<<"constructor by parameter"<<data<<endl;  
20.     }  
21. };  
22.   
23. B play(B b)  
24. {  
25.     return b;  
26. }  

分析下面两个main()函数的输出。

第一个main函数：

[cpp]  view plain  copy

1. int main()  
2. {  
3.     B t1 = play(5);  
4.     B t2 = play(t1);  
5.   
6.     return 0;  
7. }  

第二个main函数：

[cpp]  view plain  copy

1. int main()  
2. {  
3.     B t1 = play(5);  
4.     B t2 = play(10);  
5.   
6.     return 0;  
7. }  

解析：

　　这里调用play函数时，有两种参数类型的传递方式。

　　如果传递的参数是整型，那么在其函数栈中首先会调用带参数的构造函数，产生一个临时对象，然后返回前（在return代码执行时）调用类的复制构造函数，生成临时对象（这样函数返回后主函数中的对象就被初始化了），最后这个临时对象会在函数返回时（在return代码执行后）析构。

　　如果传递的参数是B类的对象，那么只有第一步与上面的不同，就是其函数栈中会首先调用复制构造函数产生一个临时对象，其余步骤完全相同。

　　可以看出，两种情况的区别是采用了不同的方法生成临时对象（一个是调用带参数的构造函数，另一个是调用复制构造函数）。

　　在第一个main函数中，te使用了传入整型数的方法调用play函数，而对象t2使用了传入B的对象的方式调用play函数。在第二个main函数中，对象t1和t2都使用了传入整型数的方式调用play函数。

第一个main函数执行结果：

[cpp]  view plain  copy

1. constructor by parameter5         （调用带参数的构造函数，在fun内生成临时对象）  
2. destructed                        （5传入fun时生成的临时对象析构）  
3. destructed                        （t1传入fun时产生的返回的临时对象析构）  
4. destructed                        （t2析构）  
5. destructed                        （t1析构）  

第二个main函数的执行结果：

[cpp]  view plain  copy

1. constructor by parameter5         （调用带参数的构造函数，在fun内生成临时对象）  
2. destructed                        （5传入fun时生成的临时对象析构）  
3. constructor by parameter10        （调用带参数的构造函数，在fun内生成临时对象）  
4. destructed                        （10传入fun时生成的临时对象析构）  
5. destructed                        （t2析构）  
6. destructed                        （t1析构）