[关闭]
@lishuhuakai 2015-05-21T14:22:40.000000Z 字数 4928 阅读 1653

C++的构造函数

c++

构造函数

构造函数是用于创建对象的特殊成员函数， 当创建对象时，系统自动调用构造函数构造函数的作用是：
* 为对象分配空间；对数据成员赋初值；请求其他资源
* 没有用户定义的构造函数时，系统提供缺省版本的构造函数

构造函数名与类名相同：类名
构造函数可以重载，构造函数可以有任意类型的参数，但没有返回类型。

析构函数

析构函数是用于取消对象的成员函数，当一个对象作用域结束时，系统自动调用析构函数。析构函数的作用是进行清除对象，释放内存等。没有用户定义析构函数时，系统提供缺省版本的析构函数。
析构函数名为：~ 类名
析构函数没有参数，也没有返回类型。

拷贝构造函数(复制构造函数)

拷贝构造函数用一个已有同类对象的数据对正在建立的对象进行数据初始化，C++为类提供默认版本的复制构造函数，程序员可以定义用户版本的复制构造函数。
语法形式
类名 :: 类名（const 类名 & 引用名 , …）;

调用拷贝构造函数的四个场景

  1. #include "iostream"
  2. using namespace std;
  4. class Test
  5. {
  6. public:
  7.     //有参构造函数
  8.     Test(int a)
  9.     {
  10.         m_a = a;
  11.     }
  12.     //无参数构造函数
  13.     Test()
  14.     {
  15.         m_a = 0;
  16.     }
  17.     //赋值构造函数 copy构造函数
  18.     Test(const Test &obj)
  19.     {
  20.         cout << "我也是构造函数啊。。。。。。" << endl;
  21.     }
  22. private:
  23.     int m_a;
  24. };
  26. void main()
  27. {
  28.     Test t1;
  29.     Test t2(t1); //用t1来初始化t2,调用拷贝构造函数
  30. }
  1. #include <iostream>
  2. using namespace std;
  4. class Location
  5. {
  6. public:
  7.     Location( int xx = 0 , int yy = 0 )
  8.     {
  9.         X = xx ; 
  10.         Y = yy ;  
  11.         cout << "Constructor Object.\n";
  12.     }
  14.     Location( const Location & p ) //复制构造函数
  15.     {
  16.         X = p.X ;  
  17.         Y = p.Y ;   
  18.         cout << "Copy_constructor called." << endl ;  
  19.     }
  21.     ~Location() 
  22.     { 
  23.         cout << X << "," << Y << " Object destroyed." << endl; 
  24.     }
  25.     int  GetX () 
  26.     { 
  27.         return X; 
  28.     }
  29.     int GetY () 
  30.     { 
  31.         return Y; 
  32.     }
  34. private :   
  35.     int  X , Y;
  36. } ;
  37. void f (Location  p)
  38. {
  39.     cout << "Funtion:" << p.GetX() << "," << p.GetY() << endl;
  40. }
  41. void playobjmain()
  42. {
  43.     Location A ( 1, 2 ) ;
  44.     f(A);//将对象A传递给f函数做实参，会调用拷贝构造函数，很好理解，这和前面的第一种方法类似，用对象A初始化一个新构建的Location对象
  45. }
  47. int main()
  48. {
  49.     playobjmain();
  50.     //system("pause");
  51.     return 0;
  52. }
  1. Test t1;
  2. Test t2 = t1;
  3. /**
  4. 上面是用t1初始化t2,调用的是拷贝构造函数。
  5. */
  6. Test t3;
  7. t3 = t1;
  8. /**
  9. t3已经初始化过了，因此不会再调用拷贝构造函数，它会调用“=”操作。
  10. */
  1. #include <iostream>
  2. using namespace std;
  4. class Test
  5. {
  6. public:
  8.     //有参构造函数
  9.     Test(int a)
  10.     {
  11.         m_a = a;
  12.     }
  13.     //无参数构造函数
  14.     Test()
  15.     {
  16.         m_a = 0;
  17.     }
  18.     //赋值构造函数 copy构造函数
  19.     Test(const Test &obj)
  20.     {
  21.         cout << "我也是构造函数啊。。。。。。" << endl;
  22.     }
  23. public:
  24.     void print()
  25.     {
  26.         cout << "m_a" << m_a << endl;
  27.     }
  28. private:
  29.     int m_a;
  30. };
  32. void play()
  33. {
  35.     Test t1;
  36.     Test t3;
  37.     /**
  38.     1. 赋值构造函数和=操作是两个不同的概念
  39.     2. 赋值构造函数（copy构造函数）也是构造函数
  40.     */
  41.     //第三种场景，t2被创建，并且自动调用copy构造函数
  42.     Test t2 = t1; //对象t2的初始化，当我们没有编写copy构造函数，执行的是浅拷贝
  43.     t2 = t1; //是对象的“=”（赋值）操作
  44. }
  46. void main()
  47. {
  48.     play();
  49.     Test t1;
  50.     //直接用t1初始化t2,调用拷贝构造函数
  51.     Test t2(t1);
  52.     system("pause");
  53. }
  54. /**
  55. 运行结果如下:
  56. 我也是构造函数啊。。。。。。
  57. 我也是构造函数啊。。。。。。
  58. */
  1. #include "iostream"
  2. using namespace std;
  4. class Location
  5. {
  6. public:
  7.     Location(int xx = 0, int yy = 0)
  8.     {
  9.         X = xx;  
  10.         Y = yy;  
  11.         cout << "Constructor Object.\n";
  12.     }
  13.     Location(const Location & p)        //复制构造函数
  14.     {
  15.         X = p.X;  
  16.         Y = p.Y;   
  17.         cout << "Copy_constructor called." << endl;
  18.     }
  19.     ~Location() 
  20.     { 
  21.         cout << X << "," << Y << " Object destroyed." << endl;
  22.     }
  23.     int  GetX() 
  24.     { 
  25.         return X; 
  26.     }       
  27.     int GetY() 
  28.     { 
  29.         return Y; 
  30.     }
  31. private:   
  32.     int  X, Y;
  33. };
  35. void f(Location  p)
  36. {
  37.     cout << "Funtion:" << p.GetX() << "," << p.GetY() << endl;
  38. }
  41. Location g()
  42. {
  43.     Location A(1, 2);
  44.     return A;
  45.     /**
  46.     将A传回去的时候，会创建一个匿名对象，因为主函数调用g函数的时候，g中的变量都在栈里面，函数结束之后东西会被清空掉，因此，返回的时候会c++会构建一个匿名的对象，并用A来初始化该匿名对象，然后才会调用A的析构函数销毁A
  47.     */
  48. }
  49. void play()
  50. {
  51.     Location B;
  52.     B = g(); 
  53.     /**
  54.     调用“=”运算符，用返回的匿名对象给B赋完值之后，匿名对象会马上析构掉，你可以运行改程序查看一下。
  55.     */
  56.     printf("hello, boy!\n");
  57. }
  59. int main()
  60. {
  61.     play();
  62.     system("pause");
  63.     return 0;
  64. }
  66. /**
  67. Constructor Object.
  68. Constructor Object.
  69. Copy_constructor called.
  70. 1,2 Object destroyed.
  71. 1,2 Object destroyed.
  72. hello, boy!
  73. 1,2 Object destroyed.
  74. */

深拷贝和浅拷贝

即使我们一个类里面什么东西也不写，c++也会默认给我们提供一些东西：

当然默认提供的无参构造函数和析构函数几乎什么也不干。拷贝构造函数和赋值操作函数就是单纯的内存拷贝，也就是浅拷贝。

  1. #include <iostream>
  2. using namespace std;
  4. class name
  5. {
  6. public:
  7.     name(char *pn);
  8.     ~name();
  9. protected:
  10.     char *pname;       
  11.     int size;
  12. public:
  13.     char * getPn()
  14.     {
  15.         return pname;
  16.     }
  17. };
  18. name::name(char *pn)
  19. {
  20.     cout << " Constructing " << pn << endl;
  21.     pname = (char *)malloc(strlen(pn) + 1);
  22.     if (pname != 0) strcpy(pname, pn);
  23.     size = strlen(pn);
  24. }
  25. name :: ~name()
  26. {
  27.     cout << " Destructing " << pname << endl;
  28.     pname[0] = '\0';
  29.     free(pname);
  30.     size = 0;
  31. }
  34. void playmain()
  35. {
  36.     name obj1("name1");
  37.     //如果你不写copy构造函数，那么C++编译器会给我们提供一个默认的copy构造函数 （浅copy）
  38.     name obj2 = obj1;
  39. }
  40. /**
  41. 程序会扑街，c++默认提供的拷贝构造函数等同于memcpy，obj2中的pname和obj1中的pname指向同一处地方，playmain析构的时候pname指向的地址会被free两次，自然会出错。
  42. */
  43. void main()
  44. {
  45.     playmain();
  47.     system("pause");
  48. }

如果改为赋值操作，也会出现相同的问题:

  1. #include <iostream>
  2. using namespace std;
  4. class name
  5. {
  6. public:
  7.     name(char *pn);
  8.     name();
  9.     ~name();
  10. protected:
  11.     char *pname;       int size;
  12. public:
  13.     char * getPn()
  14.     {
  15.         return pname;
  16.     }
  17. };
  18. name::name()
  19. {
  20.     cout << " Constructing " << endl;
  21.     pname = NULL;
  22.     size = 0;
  23. }
  24. name::name(char *pn)
  25. {
  26.     cout << " Constructing " << pn << endl;
  27.     pname = (char *)malloc(strlen(pn) + 1);
  28.     if (pname != 0) strcpy(pname, pn);
  29.     size = strlen(pn);
  30. }
  31. name :: ~name()
  32. {
  33.     cout << " Destructing " << pname << endl;
  34.     pname[0] = '\0';
  35.     free(pname);
  36.     size = 0;
  37. }
  40. void playmain()
  41. {
  42.     name obj1("name1");
  43.     name obj2("11");
  44.     //如果你不写=操作，那么C++编译器会给我们提供一个=操作函数 （浅cpy）
  45.     obj2 = obj1;
  46.     cout << obj2.getPn() << endl;
  47. }
  49. void main()
  50. {
  51.     playmain();
  52.     system("pause");
  53. }

原因是类似的，对于这中情况，我们要拒绝编译器给我们默认生成的“=”和拷贝构造函数:

  1. #include <iostream>
  2. using namespace std;
  4. class name
  5. {
  6. public:
  7.     name(char *pn);
  8.     name(name &obj)
  9.     {
  10.         cout << " copy Constructing " << endl;
  11.         char *pn = obj.getPn();
  12.         pname = (char *)malloc(strlen(pn) + 1);
  13.         if (pname != NULL) strcpy(pname, pn);
  14.         size = strlen(pn);
  15.     }
  16.     ~name();
  17. protected:
  18.     char *pname;       int size;
  19. public:
  20.     char * getPn()
  21.     {
  22.         return pname;
  23.     }
  24.     void operator=(name &obj1)
  25.     {
  26.         cout << " 执行=操作" << endl;
  27.         char *pn = obj1.getPn();
  28.         pname = (char *)malloc(strlen(pn) + 1);
  29.         if (pname != NULL) strcpy(pname, pn);
  31.         size = strlen(pn);
  32.     }
  33. };
  34. name::name(char *pn)
  35. {
  36.     cout << " Constructing " << pn << endl;
  37.     pname = (char *)malloc(strlen(pn) + 1);
  38.     if (pname != 0) strcpy(pname, pn);
  39.     size = strlen(pn);
  40. }
  41. name :: ~name()
  42. {
  43.     cout << " Destructing " << pname << endl;
  44.     pname[0] = '\0';
  45.     free(pname);
  46.     size = 0;
  47. }
  50. void playmain()
  51. {
  52.     name obj1("name1");
  53.     //如果你不写copy构造函数，那么C++编译器会给我们提供一个默认的copy构造函数 （浅cpy）
  54.     name obj2 = obj1;
  56.     //如果你不写=操作，那么C++编译器会给我们提供一个=操作函数 （浅cpy）
  57.     obj2 = obj1;
  58.     cout << obj2.getPn() << endl;
  59. }
  61. void main()
  62. {
  63.     playmain();
  64.     system("pause");
  65. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注