调用拷贝构造函数的几种情况（附面试题）

1. 深拷贝和浅拷贝（拷贝构造函数的使用）

 

有时候需要自己定义拷贝构造函数，以避免浅拷贝问题。

在什么情况下需要用户自己定义拷贝构造函数：

一般情况下，当类中成员有指针变量、类中有动态内存分配时常常需要用户自己定义拷贝构造函数。

 

在什么情况下系统会调用拷贝构造函数：（三种情况）

（1）用类的一个对象去初始化另一个对象时

（2）当函数的形参是类的对象时（也就是值传递时），如果是引用传递则不会调用

（3）当函数的返回值是类的对象或引用时

 

简单示例：

[cpp]  view plain  copy

1. 
   #include <iostream>  
2. 
   using namespace std;  
3. 
     
4. 
   class A  
5. 
   {  
6. 
   private:  
7. 
       int a;  
8. 
   public:  
9. 
       A(int i){a=i;}  //内联的构造函数  
10. 
        A(A &aa);  
11. 
        int geta(){return a;}  
12. 
    };  
13. 
      
14. 
    A::A(A &aa)     //拷贝构造函数  
15. 
    {  
16. 
        a=aa.a;  
17. 
        cout<<”拷贝构造函数执行！”<<endl;  
18. 
    }  
19. 
      
20. 
    int get_a(A aa)     //参数是对象，是值传递，会调用拷贝构造函数  
21. 
    {  
22. 
        return aa.geta();  
23. 
    }  
24. 
      
25. 
    int get_a_1(A &aa)  //如果参数是引用类型，本身就是引用传递，所以不会调用拷贝构造函数  
26. 
    {  
27. 
        return aa.geta();  
28. 
    }  
29. 
      
30. 
    A get_A()       //返回值是对象类型，会调用拷贝构造函数。会调用拷贝构造函数，因为函数体内生成的对象aa是临时的，离开这个函数就消失了。所有会调用拷贝构造函数复制一份。  
31. 
    {  
32. 
        A aa(1);  
33. 
        return aa;  
34. 
    }  
35. 
      
36. 
    A& get_A_1()    //会调用拷贝构造函数，因为函数体内生成的对象aa是临时的，离开这个函数就消失了。所有会调用拷贝构造函数复制一份。  
37. 
    {  
38. 
        A aa(1);  
39. 
        return aa;  
40. 
    }  
41. 
      
42. 
    int _tmain(int argc, _TCHAR* argv[])  
43. 
    {  
44. 
        A a1(1);  
45. 
        A b1(a1);           //用a1初始化b1，调用拷贝构造函数  
46. 
        A c1=a1;            //用a1初始化c1，调用拷贝构造函数  
47. 
      
48. 
        int i=get_a(a1);        //函数形参是类的对象，调用拷贝构造函数  
49. 
        int j=get_a_1(a1);      //函数形参类型是引用，不调用拷贝构造函数  
50. 
      
51. 
        A d1=get_A();       //调用拷贝构造函数  
52. 
        A e1=get_A_1();     //调用拷贝构造函数  
53. 
      
54. 
        return 0;  
55. 
    }  

 

附：一个面试试题

修改下面程序中的错误：

[cpp]  view plain  copy

1. 
   #include <iostream>  
2. 
   using namespace std;  
3. 
     
4. 
   class NameStr  
5. 
   {  
6. 
   private:  
7. 
       char *m_pName;  
8. 
       char *m_pData;  
9. 
   public:  
10. 
        NameStr()  
11. 
        {  
12. 
            static const char s_szDefaultName[]=“Default name”;  
13. 
            static const char s_szDefaultStr[]=“Default string”;  
14. 
            strcpy(m_pName,s_szDefaultName);  
15. 
            strcpy(m_pData,s_szDefaultStr);  
16. 
        }  
17. 
        ~NamedStr(){}  
18. 
        NameStr(const char pName,const char pData)  
19. 
        {  
20. 
            m_pData=new char[strlen(pData)];  
21. 
            m_pName=new char[strlen(pData)];  
22. 
        }  
23. 
      
24. 
        void Print()  
25. 
        {  
26. 
            cout<<”Name:”<<m_pName<<endl;  
27. 
            cout<<”String:”<<m_pData<<endl;  
28. 
        }  
29. 
    };  
30. 
      
31. 
    int _tmain(int argc, _TCHAR* argv[])  
32. 
    {  
33. 
        NameStr* pDefNss=NULL;  
34. 
      
35. 
        pDefNss=new NameStr[10];  
36. 
        NameStr ns(”hello”,“world”);  
37. 
      
38. 
        delete pDefNss;  
39. 
      
40. 
        return 0;  
41. 
    }  

分析：

1. 第14、15行，strcpy(m_pName,s_szDefaultName) 对未分配内存空间的字符指针赋值会出现异常。

2. 第20行、21行，m_pData=new char[strlen(pData)] 应该为m_pData=new char[strlen(pData)+1] ，并且应该为最后一个字符赋值为’\0’。

3. 析构函数中，应该处理字符指针内存空间的释放。

4. 因为类的成员变量中有指针变量，因此应该编写类的拷贝构造函数和赋值函数，防止浅拷贝。

5. pDefNss是一个对象数组，delete时应该是delete [ ]pDefNss。

 

比较规范的代码如下：

[cpp]  view plain  copy

1. 
   #include <iostream>  
2. 
   using namespace std;  
3. 
     
4. 
   //NameStr类的声明  
5. 
   class NameStr  
6. 
   {  
7. 
   private:  
8. 
       char *m_pName;  
9. 
       char *m_pData;  
10. 
    public:  
11. 
        NameStr();      //默认拷贝构造函数  
12. 
      
13. 
        ~NameStr(); //析构函数声明  
14. 
      
15. 
        NameStr(const char pName,const char pData);   //带参构造函数的声明  
16. 
      
17. 
        NameStr(const NameStr& temp);   //拷贝构造函数的声明  
18. 
      
19. 
        NameStr& operator= (const NameStr& temp);   //重载=运算符  
20. 
      
21. 
        void Print();   //输出对象内容  
22. 
    };  
23. 
      
24. 
    //默认构造函数的实现  
25. 
    NameStr::NameStr()    
26. 
    {  
27. 
        static const char s_szDefaultName[]=“Default name”;  
28. 
        static const char s_szDefaultStr[]=“Default string”;  
29. 
      
30. 
        m_pData=new char[strlen(s_szDefaultStr)+1];     //不能为为分配内存空间的字符指针赋值  
31. 
        m_pName=new char[strlen(s_szDefaultName)+1];  
32. 
      
33. 
        strcpy(m_pName,s_szDefaultName);        //更规范的方式是使用strncpy函数进行拷贝  
34. 
        m_pName[strlen(s_szDefaultName)]=’\0’;  
35. 
        strcpy(m_pData,s_szDefaultStr);  
36. 
        m_pData[strlen(s_szDefaultStr)]=’\0’;  
37. 
    }  
38. 
      
39. 
    //析构函数的实现  
40. 
    NameStr::~NameStr()  
41. 
    {  
42. 
        delete []m_pData;  
43. 
        delete []m_pName;  
44. 
    }  
45. 
      
46. 
    //带参构造函数的实现  
47. 
    NameStr::NameStr(const char pName,const char pData)  
48. 
    {  
49. 
        m_pData=new char[strlen(pData)+1];      //开辟内存空间  
50. 
        m_pName=new char[strlen(pName)+1];  
51. 
      
52. 
        strcpy(m_pData,pData);  
53. 
        m_pData[strlen(pData)]=’\0’;  
54. 
        strcpy(m_pName,pName);  
55. 
        m_pName[strlen(pName)]=’\0’;  
56. 
    }  
57. 
      
58. 
    //拷贝构造函数的实现  
59. 
    NameStr::NameStr(const NameStr& temp)  
60. 
    {  
61. 
        m_pData=new char[strlen(temp.m_pData)+1];         
62. 
        m_pName=new char[strlen(temp.m_pName)+1];  
63. 
      
64. 
        strcpy(m_pData,temp.m_pData);  
65. 
        m_pData[strlen(temp.m_pData)]=’\0’;  
66. 
        strcpy(m_pName,temp.m_pName);  
67. 
        m_pName[strlen(temp.m_pName)]=’\0’;  
68. 
    }  
69. 
      
70. 
    //重载=运算符的实现  
71. 
    NameStr& NameStr::operator=(const NameStr& temp)      
72. 
    {  
73. 
        //首先要进行检查，防止自身复制  
74. 
        if(&temp==this) //this是一个指针，表示本对象的地址。&temp是temp对象的指针。  
75. 
        {  
76. 
            return *this;  
77. 
        }  
78. 
      
79. 
        //释放原有的内存空间  
80. 
        delete []m_pData;  
81. 
        delete []m_pName;  
82. 
      
83. 
        //分配新的内存空间  
84. 
        m_pData=new char[strlen(temp.m_pData)+1];         
85. 
        m_pName=new char[strlen(temp.m_pName)+1];  
86. 
      
87. 
        //进行拷贝  
88. 
        strcpy(m_pData,temp.m_pData);  
89. 
        m_pData[strlen(temp.m_pData)]=’\0’;  
90. 
        strcpy(m_pName,temp.m_pName);  
91. 
        m_pName[strlen(temp.m_pName)]=’\0’;  
92. 
      
93. 
        //返回本对象的引用  
94. 
        return *this;  
95. 
    }  
96. 
      
97. 
    inline void NameStr::Print()  
98. 
    {  
99. 
        cout<<”Name:”<<m_pName<<endl;  
100. 
         cout<<”String:”<<m_pData<<endl;  
101. 
     }  
102. 
       
103. 
     //程序入口  
104. 
     int _tmain(int argc, _TCHAR* argv[])  
105. 
     {  
106. 
         NameStr* pDefNss=NULL;  
107. 
       
108. 
         pDefNss=new NameStr[3];  
109. 
         NameStr ns(”hello”,“world”);  
110. 
       
111. 
         delete []pDefNss;  
112. 
       
113. 
         NameStr ns1=ns;  
114. 
       
115. 
         return 0;  
116. 
     }  

转自： http://blog.csdn.net/hyhyl1990/article/details/7957604

1. 深拷贝和浅拷贝（拷贝构造函数的使用）

 

有时候需要自己定义拷贝构造函数，以避免浅拷贝问题。

在什么情况下需要用户自己定义拷贝构造函数：

一般情况下，当类中成员有指针变量、类中有动态内存分配时常常需要用户自己定义拷贝构造函数。

 

在什么情况下系统会调用拷贝构造函数：（三种情况）

（1）用类的一个对象去初始化另一个对象时

（2）当函数的形参是类的对象时（也就是值传递时），如果是引用传递则不会调用

（3）当函数的返回值是类的对象或引用时

 

简单示例：

[cpp]  view plain  copy

1. 
   #include <iostream>  
2. 
   using namespace std;  
3. 
     
4. 
   class A  
5. 
   {  
6. 
   private:  
7. 
       int a;  
8. 
   public:  
9. 
       A(int i){a=i;}  //内联的构造函数  
10. 
        A(A &aa);  
11. 
        int geta(){return a;}  
12. 
    };  
13. 
      
14. 
    A::A(A &aa)     //拷贝构造函数  
15. 
    {  
16. 
        a=aa.a;  
17. 
        cout<<”拷贝构造函数执行！”<<endl;  
18. 
    }  
19. 
      
20. 
    int get_a(A aa)     //参数是对象，是值传递，会调用拷贝构造函数  
21. 
    {  
22. 
        return aa.geta();  
23. 
    }  
24. 
      
25. 
    int get_a_1(A &aa)  //如果参数是引用类型，本身就是引用传递，所以不会调用拷贝构造函数  
26. 
    {  
27. 
        return aa.geta();  
28. 
    }  
29. 
      
30. 
    A get_A()       //返回值是对象类型，会调用拷贝构造函数。会调用拷贝构造函数，因为函数体内生成的对象aa是临时的，离开这个函数就消失了。所有会调用拷贝构造函数复制一份。  
31. 
    {  
32. 
        A aa(1);  
33. 
        return aa;  
34. 
    }  
35. 
      
36. 
    A& get_A_1()    //会调用拷贝构造函数，因为函数体内生成的对象aa是临时的，离开这个函数就消失了。所有会调用拷贝构造函数复制一份。  
37. 
    {  
38. 
        A aa(1);  
39. 
        return aa;  
40. 
    }  
41. 
      
42. 
    int _tmain(int argc, _TCHAR* argv[])  
43. 
    {  
44. 
        A a1(1);  
45. 
        A b1(a1);           //用a1初始化b1，调用拷贝构造函数  
46. 
        A c1=a1;            //用a1初始化c1，调用拷贝构造函数  
47. 
      
48. 
        int i=get_a(a1);        //函数形参是类的对象，调用拷贝构造函数  
49. 
        int j=get_a_1(a1);      //函数形参类型是引用，不调用拷贝构造函数  
50. 
      
51. 
        A d1=get_A();       //调用拷贝构造函数  
52. 
        A e1=get_A_1();     //调用拷贝构造函数  
53. 
      
54. 
        return 0;  
55. 
    }  

 

附：一个面试试题

修改下面程序中的错误：

[cpp]  view plain  copy

1. 
   #include <iostream>  
2. 
   using namespace std;  
3. 
     
4. 
   class NameStr  
5. 
   {  
6. 
   private:  
7. 
       char *m_pName;  
8. 
       char *m_pData;  
9. 
   public:  
10. 
        NameStr()  
11. 
        {  
12. 
            static const char s_szDefaultName[]=“Default name”;  
13. 
            static const char s_szDefaultStr[]=“Default string”;  
14. 
            strcpy(m_pName,s_szDefaultName);  
15. 
            strcpy(m_pData,s_szDefaultStr);  
16. 
        }  
17. 
        ~NamedStr(){}  
18. 
        NameStr(const char pName,const char pData)  
19. 
        {  
20. 
            m_pData=new char[strlen(pData)];  
21. 
            m_pName=new char[strlen(pData)];  
22. 
        }  
23. 
      
24. 
        void Print()  
25. 
        {  
26. 
            cout<<”Name:”<<m_pName<<endl;  
27. 
            cout<<”String:”<<m_pData<<endl;  
28. 
        }  
29. 
    };  
30. 
      
31. 
    int _tmain(int argc, _TCHAR* argv[])  
32. 
    {  
33. 
        NameStr* pDefNss=NULL;  
34. 
      
35. 
        pDefNss=new NameStr[10];  
36. 
        NameStr ns(”hello”,“world”);  
37. 
      
38. 
        delete pDefNss;  
39. 
      
40. 
        return 0;  
41. 
    }  

分析：

1. 第14、15行，strcpy(m_pName,s_szDefaultName) 对未分配内存空间的字符指针赋值会出现异常。

2. 第20行、21行，m_pData=new char[strlen(pData)] 应该为m_pData=new char[strlen(pData)+1] ，并且应该为最后一个字符赋值为’\0’。

3. 析构函数中，应该处理字符指针内存空间的释放。

4. 因为类的成员变量中有指针变量，因此应该编写类的拷贝构造函数和赋值函数，防止浅拷贝。

5. pDefNss是一个对象数组，delete时应该是delete [ ]pDefNss。

 

比较规范的代码如下：

[cpp]  view plain  copy

1. 
   #include <iostream>  
2. 
   using namespace std;  
3. 
     
4. 
   //NameStr类的声明  
5. 
   class NameStr  
6. 
   {  
7. 
   private:  
8. 
       char *m_pName;  
9. 
       char *m_pData;  
10. 
    public:  
11. 
        NameStr();      //默认拷贝构造函数  
12. 
      
13. 
        ~NameStr(); //析构函数声明  
14. 
      
15. 
        NameStr(const char pName,const char pData);   //带参构造函数的声明  
16. 
      
17. 
        NameStr(const NameStr& temp);   //拷贝构造函数的声明  
18. 
      
19. 
        NameStr& operator= (const NameStr& temp);   //重载=运算符  
20. 
      
21. 
        void Print();   //输出对象内容  
22. 
    };  
23. 
      
24. 
    //默认构造函数的实现  
25. 
    NameStr::NameStr()    
26. 
    {  
27. 
        static const char s_szDefaultName[]=“Default name”;  
28. 
        static const char s_szDefaultStr[]=“Default string”;  
29. 
      
30. 
        m_pData=new char[strlen(s_szDefaultStr)+1];     //不能为为分配内存空间的字符指针赋值  
31. 
        m_pName=new char[strlen(s_szDefaultName)+1];  
32. 
      
33. 
        strcpy(m_pName,s_szDefaultName);        //更规范的方式是使用strncpy函数进行拷贝  
34. 
        m_pName[strlen(s_szDefaultName)]=’\0’;  
35. 
        strcpy(m_pData,s_szDefaultStr);  
36. 
        m_pData[strlen(s_szDefaultStr)]=’\0’;  
37. 
    }  
38. 
      
39. 
    //析构函数的实现  
40. 
    NameStr::~NameStr()  
41. 
    {  
42. 
        delete []m_pData;  
43. 
        delete []m_pName;  
44. 
    }  
45. 
      
46. 
    //带参构造函数的实现  
47. 
    NameStr::NameStr(const char pName,const char pData)  
48. 
    {  
49. 
        m_pData=new char[strlen(pData)+1];      //开辟内存空间  
50. 
        m_pName=new char[strlen(pName)+1];  
51. 
      
52. 
        strcpy(m_pData,pData);  
53. 
        m_pData[strlen(pData)]=’\0’;  
54. 
        strcpy(m_pName,pName);  
55. 
        m_pName[strlen(pName)]=’\0’;  
56. 
    }  
57. 
      
58. 
    //拷贝构造函数的实现  
59. 
    NameStr::NameStr(const NameStr& temp)  
60. 
    {  
61. 
        m_pData=new char[strlen(temp.m_pData)+1];         
62. 
        m_pName=new char[strlen(temp.m_pName)+1];  
63. 
      
64. 
        strcpy(m_pData,temp.m_pData);  
65. 
        m_pData[strlen(temp.m_pData)]=’\0’;  
66. 
        strcpy(m_pName,temp.m_pName);  
67. 
        m_pName[strlen(temp.m_pName)]=’\0’;  
68. 
    }  
69. 
      
70. 
    //重载=运算符的实现  
71. 
    NameStr& NameStr::operator=(const NameStr& temp)      
72. 
    {  
73. 
        //首先要进行检查，防止自身复制  
74. 
        if(&temp==this) //this是一个指针，表示本对象的地址。&temp是temp对象的指针。  
75. 
        {  
76. 
            return *this;  
77. 
        }  
78. 
      
79. 
        //释放原有的内存空间  
80. 
        delete []m_pData;  
81. 
        delete []m_pName;  
82. 
      
83. 
        //分配新的内存空间  
84. 
        m_pData=new char[strlen(temp.m_pData)+1];         
85. 
        m_pName=new char[strlen(temp.m_pName)+1];  
86. 
      
87. 
        //进行拷贝  
88. 
        strcpy(m_pData,temp.m_pData);  
89. 
        m_pData[strlen(temp.m_pData)]=’\0’;  
90. 
        strcpy(m_pName,temp.m_pName);  
91. 
        m_pName[strlen(temp.m_pName)]=’\0’;  
92. 
      
93. 
        //返回本对象的引用  
94. 
        return *this;  
95. 
    }  
96. 
      
97. 
    inline void NameStr::Print()  
98. 
    {  
99. 
        cout<<”Name:”<<m_pName<<endl;  
100. 
         cout<<”String:”<<m_pData<<endl;  
101. 
     }  
102. 
       
103. 
     //程序入口  
104. 
     int _tmain(int argc, _TCHAR* argv[])  
105. 
     {  
106. 
         NameStr* pDefNss=NULL;  
107. 
       
108. 
         pDefNss=new NameStr[3];  
109. 
         NameStr ns(”hello”,“world”);  
110. 
       
111. 
         delete []pDefNss;  
112. 
       
113. 
         NameStr ns1=ns;  
114. 
       
115. 
         return 0;  
116. 
     }  

转自： http://blog.csdn.net/hyhyl1990/article/details/7957604