C++拷贝构造函数的学习(一)

     拷贝构造函数:功能：使用一个已经存在的对象来初始化一个新的同一类型的对象

 

     拷贝构造函数的声明：只有一个参数，并且 参数为该对象的引用

     如果类中没有说明拷贝构造函数，则系统自动生成一个缺省复制构造函数，作为该类的公有成员。

     拷贝函数的参数必须是对象引用。

 

     在C++中，下面三种对象需要调用拷贝构造函数：

      1) 一个 对象作为 函数参数，以 值传递的方式 传入函数体；

      2) 一个 对象作为 函数返回值，以 值传递的方式从函数 返回；

      3) 一个 对象用于给 另一个对象进行 初始化（常称为复制初始化）；

 

    1.当函数的 形参是 类的对象，调用函数时，进行形参与实参结合时使用，这时要在内存新建立一个 局部对象，并把 实参拷贝到新的对象中，理所当然也要调用拷贝构造函数。

    2.当函数的 返回值是类的对象，函数执行完成返回调用者时使用。理由也是要建立一个临时对象中，再返回调用者。为什么不直接用要返回的局部对象呢？因为 局部对象在离开建立它的函数时就消亡了，不可能在返回调用函数后继续生存，所以处理这种情况时，编译系统会在调用函数的表达式中创建一个 无名临时对象，该临时对象在生存周期值在函数调用处的表达式中。

    3.所谓return对象，实际上是调用拷贝构造函数把该对象的值拷入 临时对象，如果返回的是变量，处理过程类似，只是不用调用构造函数。

    4. 拷贝构造函数的另一种调用：当对象直接作为 参数 传给函数时，函数将建立对象的 临时拷贝 ，这个拷贝过程也将调用拷贝构造函数。

 

 Test.h

 

1. # ifndef _TEST_H_ 
2. # define _TEST_H_ 
3.  
4. class Test 
5. { 
6. public: 
7.     Test(); 
8.     Test(int num); 
9. //拷贝函数的参数必须是对象引用 
10.     Test(const Test& other); 
11.     ~Test(); 
12.  
13.     Test& operator = (const Test& other); 
14.  
15.     void Display(); 
16.  
17. private: 
18.     int num_; 
19. }; 
20.  
21. # endif //_TEST 

Test.cpp

 

1. # include "Test.h" 
2. # include <iostream> 
3. using namespace std; 
4.  
5. Test::Test():num_(0) 
6. { 
7.     cout << num_ << endl; 
8. } 
9.  
10. Test::Test(int num):num_(num) 
11. { 
12.     cout << num_<<endl; 
13. } 
14.  
15.  
16. Test::~Test() 
17. { 
18.     cout << "Destory " << num_ << endl; 
19. } 
20.  
21. Test::Test(const Test& other):num_(other.num_) 
22. { 
23.     cout <<"Inilializing with other " << endl; 
24. } 
25.  
26. Test& Test::operator=(const Test& other) 
27. { 
28.     cout << "Test::operator" << endl; 
29.     if(this == &other) 
30.     { 
31.         return *this; //t = t; 直接返回 
32.     } 
33.     num_ = other.num_; 
34.      
35.     return *this;//返回自身 
36. } 
37. void Test::Display() 
38. { 
39.     cout << num_ << endl; 
40. } 

main.cpp

 

1. # include "Test.h" 
2. # include <iostream> 
3. using namespace std; 
4.  
5. int main(void) 
6. { 
7.     Test t(10);//调用带一个参数的构造函数    
8. //t对象初始化t2对象，这时会调用拷贝构造函数 
9.     Test t2 = t; //此时=不是赋值运算符，而是特殊的解释 
10.  
11.     return 0; 
12. } 

 

运行结果：

 

    下面用实例讲解在什么情况下会调用拷贝构造函数，什么情况下不会调用拷贝构造函数

Test.h

 

1. # ifndef _TEST_H_ 
2. class Test 
3. { 
4. public: 
5.     Test(); 
6.     Test(int num); 
7.     //拷贝构造函数 
8.     Test(const Test&);  
9.     ~Test(); 
10.      
11.     Test& operator=(const Test& other); 
12.  
13.     void Display(); 
14.  
15. private: 
16.     int num_; 
17. }; 
18.  
19. # endif //_TEST_H_ 

Test.cpp

 

1. #include "Test.h" 
2. # include <iostream> 
3. using namespace std; 
4.  
5. Test::Test(void):num_(0) 
6. { 
7.     cout << num_ << endl; 
8. } 
9.  
10. Test::Test(int num):num_(num) 
11. { 
12.     cout << num_<<endl; 
13. } 
14.  
15. Test::~Test(void) 
16. { 
17.     cout << "Deatory ..." << endl; 
18. } 
19.  
20. Test::Test(const Test& other):num_(other.num_) 
21. { 
22.     cout << "Iniliazing with other..." << endl; 
23. } 
24.  
25. Test& Test::operator=(const Test& other) 
26. { 
27.     cout << "Test::operator "<< endl; 
28.     if(this == &other) 
29.     { 
30.         return *this; 
31.     } 
32.     num_ = other.num_; 
33.  
34.     return *this; 
35. } 
36.  
37. void Test::Display() 
38. { 
39.     cout << num_ << endl; 
40. } 

main.cpp

 

1. # include "Test.h" 
2. # include <iostream> 
3. using namespace std; 
4.  
5. void TestFun(const Test t) 
6. { 
7.      
8. } 
9. //因为是引用不会构造对象分配内存的 
10. void TestFun_reference_parameter(const Test& t) 
11. { 
12.  
13. } 
14. const Test& TestFun_const_return_reference (const Test& t) 
15. { 
16.     return t; 
17. } 
18. //返回对象的时候，要创建一个临时对象 
19. Test TestFun_return_object(const Test& t) 
20. {//进行复制操作 
21.     return t;//临时对象  
22. } 
23.  
24. int main(void) 
25. { 
26.     Test t(10);//调用拷贝构造函数 
27.     cout << "." << endl; 
28.     TestFun(t);//调用拷贝构造函数 
29.     cout << ".." << endl; 
30.     因为是引用不会构造对象分配内存的 
31.     TestFun_reference_parameter(t); 
32.  
33.     Test t2 = t;//调用拷贝构造函数 
34.     cout << "..." << endl; 
35.  
36.     TestFun_return_object(t); //调用拷贝构造函数 
37.     t = TestFun_return_object(t);//引用的话，临时对象也不会马上被销毁 
38.     cout << "...." << endl; 
39.          
40.     //TestFun(t); 
41.    Test t4 = TestFun_const_return_reference(t);//调用拷贝构造函数 ,因为返回的是t 
42.  
43.     return 0; 
44. } 

运行结果：