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析构)  
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值