C++的六个函数

一、构造函数

   在C++中，构造函数是六个函数中的第一个，当一个对象被创建时，在它的整个周期中，是一个由生到死的

过程，即构造函数创建对象，析构函数析构对象。在对象被创建时，调用构造函数创建一个对象，这是对象的创

建过程。在C++中，当你创建一个对象时需要调用构造函数创建对象，在类中，有默认的构造函数，当然你也可

以去使用构造函数去创建对象，对数据进行初始化。看下面的例子：

class Base 
{
   public:
       Base()
       {}
       Base(int a=0):num(a)
       {}
       Base(int a=0,int b=0):num(a),age(b)
       {}
       Base(int a=0,int b=0,double c=0.0):num(a),age(b),slaroy(c)
       {}
   private:
       int num;
       int age;
       double slaroy;
};

    在上面的构造函数中，构造函数必须与类名相同，构造函数是无类型的，第一个构造函数是默认的构造函数，

第二个构造函数是只对一个数据成员进行初始化，其它的数据成员是随机值。第二个构造函数是对两个数据成员

进行初始化，其它的数据成员为随机值。第三个构造函数是对所有的数据成员进行初始化。

二、析构函数

   在C++中，构造函数是创建一个对象时，那么析构函数则是这个对象由生到死的死亡过程。同时析构函数也在

析构对象时可以将已经分配的内存空间进行回收。

class Base
{
   public:
       Base()
       {}
       Base()
       {
          p= new char[strlen("default")+1];
          strcpy(p,"default");
       }
       ~Base()
       {
           if(p != NULL)
           {
              delete[] p;
              p=NULL;
           }
       }
   private:
       char *p;
};

        析构函数如上所示，它无类型、无参数、无返回值，如果在构造对象时没有进行空间的开辟内存的分配时，那么

析构函数如同默认的析构函数一样，如果进行了内存的分配时，当一个对象被析构时同时还要对其所分配的内存进行

回收，否则就会造成内存泄漏。

三、拷贝构造函数

  在C++中，如果在构造函数中有申请内存的操作，且在其他函数中出现对象的拷贝，那么就会需要拷贝构造函数。

class Base
{
   public:
       Base()
       {}
       Base()
       {
          p= new char[strlen("default")+1];
          strcpy(p,"default");
       }
       Base(const Base &s)
       {
         p= new char[strlen(s.p)+1];
         strcpy(p,s.p);
       }
       ~Base()
       {
           if(p != NULL)
           {
              delete[] p;
              p=NULL;
           }
       }
   private:
       char *p;
}; 
int main()
{
   Base a;
   Base b(a);
   return 0;
}

       由于在主函数中出现了对对象的拷贝赋值，那么就需要拷贝构造函数，如果没有拷贝构造函数，则会使用默认的

拷贝构造函数，那么此时进行的是浅拷贝，那么会产生析构函数对内存重复释放的错误。那么此时就需要进行深拷贝

操作，重新编写拷贝构造函数对对象进行拷贝赋值。而在编写拷贝构造函数时要注意参数必须是“&”引用传递，否则

则是语法错误。

四、赋值函数

   在C++中，赋值函数为第四个函数，如果在构造函数中有申请内存的操作，且在其他程序中有两个对象直接或间接

进行赋值操作，就需要赋值函数。

class Base
{
   public:
       Base()
       {}
       Base()
       {
          p= new char[strlen("default")+1];
          strcpy(p,"default");
       }
       Base(const Base &s)
       {
         p= new char[strlen(s.p)+1];
         strcpy(p,s.p);
       }
       Base& operator=(const Base &s)
       {
           if(&s==this)
              return *this;
           delete[] p;
           p= new char[strlen(s.p)+1];
           strcpy(p,s.p);
           return *this;
        }
       ~Base()
       {
           if(p != NULL)
           {
              delete[] p;
              p=NULL;
           }
       }
   private:
       char *p;
}; 
int main()
{
   Base a,c;
   Base b(a);
   c=a;
   return 0;
}

      由于在主函数中进行了对象的赋值操作，如果没有对“=”运算符进行重载定义，则会产生两次释放同一个内存的

操作的错误。在“=”重载操作中，如果涉及到指针操作，则必须判断两个对象是否为同一个对象即自赋值操作，否则

当进行释放指针的操作时，就可能产生错误。然后要用delete释放原有的内存资源，否则将造成内存泄漏。

五、对一般对象的取址函数

  在C++中，对一般对象的取址函数为第五个函数。

class Base
{
   public:
       Base* operator&()
       {
          return this;
       }
}; 

  在一般对象的取址函数是直接返回该对象的地址，则为取其地址。

六、对常对象的取址函数

  在C++中，对常对象的取址函数为第六个函数。

class Base
{
   public:
       const Base* operator&() const
       {
          return this;
       }
};

   在常对象的取址函数也是直接返回该常对象的地址，则为取其地址。