c++中的类之构造函数

一、构造函数的缘由

　　本文我们主要来讲解c++中类的构造函数，其中涉及了深拷贝和浅拷贝的问题，这也是在面试笔试中经常会碰到的问题。如果您是第一次听说构造函数，可能会觉得这个名字有点高大上，而它却和实际中的工程问题有关。在正式的讲解前，我们先来思考一个问题：（注意，本文采用的课件来源于狄泰软件学院，感谢狄泰的唐老师！）

　　

 #include <stdio.h>

 class Test
 {
 private:
     int i;
     int j;
 public:
     int getI() { return i; }
     int getJ() { return j; }
 };

 Test gt;  // 全局变量放在bss段

 int main()
 {
     // 访问全局变量gt的的成员变量值
     printf("gt.i = %d\n", gt.getI());
     printf("gt.j = %d\n", gt.getJ());

     Test t1;
     // 访问局部变量t1的的成员变量值
     printf("t1.i = %d\n", t1.getI());
     printf("t1.j = %d\n", t1.getJ());

     Test* pt = new Test;
     // 访问堆空间pt的的成员变量值
     printf("pt->i = %d\n", pt->getI());
     printf("pt->j = %d\n", pt->getJ());

     delete pt;  // 注意释放堆空间

     return ;
 }

成员变量的初始值

　　通过这个简单的例子，我们发现，同样是声明一个类的对象，因为对象所在的存储空间不同（bss段、堆空间、栈），导致其对象的成员变量的初始值不相同。对于我们类的使用者来说，我们当然不希望出现这种情况。于是，我们希望在定义一个类的对象的同时，初始化其成员变量的值，统一化，不管是在bss段，堆空间、栈上。

　　

因此，我们可以提供下面的解决方案：

　　

这样的方式虽然可以解决我们之前遇到的问题，但是在实际的使用过程中会觉得不好用。

　　

为此，c++的设计者想出了一个办法，即构造函数：

　　

注意，构造函数必须满足： 1. 与类的名字相同   2.无返回值

二、有参构造函数和重载构造函数

　　

　　

注意这里的初始化方式，即“ ()“” 和“ = ”。

　　

在创建一个对象数组的时候，我们可以手工调用构造函数来初始化该对象数组。

 #include <stdio.h>

 class Test
 {
 private:
     int m_value;
 public:
     Test()
     {
         printf("Test()\n");

         m_value = ;
     }
     Test(int v)
     {
         printf("Test(int v), v = %d\n", v);

         m_value = v;
     }
     int getValue()
     {
         return m_value;
     }
 };

 int main()
 {
     Test ta[] = {Test(), Test(), Test()};  // 手工调用构造函数

     for(int i=; i<; i++)
     {
         printf("ta[%d].getValue() = %d\n", i , ta[i].getValue());
     }

     // int i(100); // 这样的方式是初始化i
     Test t = Test(); // 初始化方式

     printf("t.getValue() = %d\n", t.getValue());

     return ;
 }

创建对象数组

三、无参构造函数和拷贝构造函数

下面来介绍两个特殊的构造函数：

　　

　　

注意：没有构造函数是指连拷贝构造函数都没有。

3.2 深拷贝和浅拷贝

　　

浅拷贝只是简单的成员变量复制。我们可以看下面的例子：

 #include <stdio.h>

 class Test
 {
 private:
     int i;
     int j;
     int* p;
 public:
     int getI()
     {
         return i;
     }
     int getJ()
     {
         return j;
     }
     int* getP()
     {
         return p;
     }
     Test(const Test& t)
     {
         i = t.i;
         j = t.j;

         /* 这里是浅拷贝，p和t.p所指向的内存空间相同
          */
         // p = t.p ; 

         /* 注意这里是深拷贝，与浅拷贝不同的是，重新在堆空间申请内存空间，
          * 并将该空间的值和t.p的相同，这样就可以使得对象的逻辑状态相同
          */
         p = new int;
         *p = *t.p;
     }
     Test(int v)
     {
         i = ;
         j = ;
         p = new int;
         *p = v;
     }
     void free()
     {
         delete p;
     }
 };

 int main()
 {
     Test t1();
     Test t2(t1); 

     printf("t1.i = %d, t1.j = %d, *t1.p = %d\n", t1.getI(), t1.getJ(), *t1.getP());
     printf("t2.i = %d, t2.j = %d, *t2.p = %d\n", t2.getI(), t2.getJ(), *t2.getP());

     t1.free();  // 释放两次，如果是浅拷贝会出问题，而深拷贝不会
     t2.free();  

     return ;
 }

深拷贝和浅拷贝

　　

既然我们已经了解了深拷贝和浅拷贝的区别，那么什么时候我们该使用深拷贝呢？

　　（即申请堆空间、打开文件、网络端口等操作）

　　

---

四、初始化列表

　　在正式讲解初始化列表前，我们先来思考一个问题：

　　　　

　　　　

实际上，我们会发现这个类并没有给成员变量ci一个初始值，所以会出错。那么我们怎么样为const 成员变量初始化一个值呢？这里就引入了初始化列表的概念。如下：

　　　　

可以看到初始化列表是在构造函数函数名之后加上一个冒号，之间用逗号隔开，m1、m2、m3是代表类的成员变量，括号里面的是对应的初始值。需要注意的是：

　　

 #include <stdio.h>

 class Value
 {
 private:
     int mi;
 public:
     Value(int i)
     {
         printf("i = %d\n", i);
         mi = i;
     }
     int getI()
     {
         return mi;
     }
 };

 class Test
 {
 private:
     // 成员变量的初始化顺序和成员变量的声明顺序有关，而与初始化列表中的位置无关
     Value m2;
     Value m3;
     Value m1;
 public:
     Test() : m1(), m2(), m3()
     {
         //由于初始化列表先于构造函数执行，所以这一句代码最后执行
         printf("Test::Test()\n");
     }
 };

 int main()
 {
     Test t;

     return ;
 }

成员变量的初始化顺序

　　我们再回到之前的那个问题：

　　

一个小问题：

　　

　　（注意，本文采用的课件来源于狄泰软件学院，感谢狄泰的唐老师！）