C++中的六個函數(shù)

一、構造函數(shù)

   在C++中，構造函數(shù)是六個函數(shù)中的第一個，當一個對象被創(chuàng)建時，在它的整個周期中，是一個由生到死的過程，即構造函數(shù)創(chuàng)建對象，析構函數(shù)析構對象。在對象被創(chuàng)建時，調用構造函數(shù)創(chuàng)建一個對象，這是對象的創(chuàng)建過程。在C++中，當你創(chuàng)建一個對象時需要調用構造函數(shù)創(chuàng)建對象，在類中，有默認的構造函數(shù)，當然你也可以去使用構造函數(shù)去創(chuàng)建對象，對數(shù)據(jù)進行初始化?？聪旅娴睦樱?/p>

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;
};

在上面的構造函數(shù)中，構造函數(shù)必須與類名相同，構造函數(shù)是無類型的，第一個構造函數(shù)是默認的構造函數(shù)，第二個構造函數(shù)是只對一個數(shù)據(jù)成員進行初始化，其它的數(shù)據(jù)成員是隨機值。第二個構造函數(shù)是對兩個數(shù)據(jù)成員進行初始化，其它的數(shù)據(jù)成員為隨機值。第三個構造函數(shù)是對所有的數(shù)據(jù)成員進行初始化。

二、析構函數(shù)

   在C++中，構造函數(shù)是創(chuàng)建一個對象時，那么析構函數(shù)則是這個對象由生到死的死亡過程。同時析構函數(shù)也在析構對象時可以將已經分配的內存空間進行回收。

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;
};

        析構函數(shù)如上所示，它無類型、無參數(shù)、無返回值，如果在構造對象時沒有進行空間的開辟內存的分配時，那么

析構函數(shù)如同默認的析構函數(shù)一樣，如果進行了內存的分配時，當一個對象被析構時同時還要對其所分配的內存進行回收，否則就會造成內存泄漏。

三、拷貝構造函數(shù)

  在C++中，如果在構造函數(shù)中有申請內存的操作，且在其他函數(shù)中出現(xiàn)對象的拷貝，那么就會需要拷貝構造函數(shù)。

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;
}

       由于在主函數(shù)中出現(xiàn)了對對象的拷貝賦值，那么就需要拷貝構造函數(shù)，如果沒有拷貝構造函數(shù)，則會使用默認的

拷貝構造函數(shù)，那么此時進行的是淺拷貝，那么會產生析構函數(shù)對內存重復釋放的錯誤。那么此時就需要進行深拷貝

操作，重新編寫拷貝構造函數(shù)對對象進行拷貝賦值。而在編寫拷貝構造函數(shù)時要注意參數(shù)必須是“&”引用傳遞，否則

則是語法錯誤。

四、賦值函數(shù)

   在C++中，賦值函數(shù)為第四個函數(shù)，如果在構造函數(shù)中有申請內存的操作，且在其他程序中有兩個對象直接或間接

進行賦值操作，就需要賦值函數(shù)。

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;
}

     由于在主函數(shù)中進行了對象的賦值操作，如果沒有對“=”運算符進行重載定義，則會產生兩次釋放同一個內存的

操作的錯誤。在“=”重載操作中，如果涉及到指針操作，則必須判斷兩個對象是否為同一個對象即自賦值操作，否則

當進行釋放指針的操作時，就可能產生錯誤。然后要用delete釋放原有的內存資源，否則將造成內存泄漏。

五、對一般對象的取址函數(shù)

  在C++中，對一般對象的取址函數(shù)為第五個函數(shù)。

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

在一般對象的取址函數(shù)是直接返回該對象的地址，則為取其地址。

六、對常對象的取址函數(shù)

  在C++中，對常對象的取址函數(shù)為第六個函數(shù)。

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

   在常對象的取址函數(shù)也是直接返回該常對象的地址，則為取其地址。