c++構造函數的做用---13

時間 2019-11-11

標籤 c++ 構造函數欄目 C&C++ 简体版

原文原文鏈接

原創博客:轉載請標明出處:http://www.cnblogs.com/zxouxuewei/ios

http://blog.csdn.net/tidyjiang/article/details/52073671c++

1、構造函數是幹什麼的函數

class Counter
{
public:
         // 類Counter的構造函數
         // 特色：以類名做爲函數名，無返回類型
         Counter()
         {
                m_value = 0;
         }
private:
          // 數據成員
         int m_value;
}

       該類對象被建立時，編譯系統對象分配內存空間，並自動調用該構造函數->由構造函數完成成員的初始化工做
eg:    Counter c1;
       編譯系統爲對象c1的每一個數據成員(m_value)分配內存空間，並調用構造函數Counter( )自動地初始化對象c1的m_value值設置爲0
故：
        構造函數的做用：初始化對象的數據成員。
2、構造函數的種類this

class Complex
{        
private :
        double    m_real;
        double    m_imag;
public:
        //    無參數構造函數
        // 若是建立一個類你沒有寫任何構造函數,則系統會自動生成默認的無參構造函數，函數爲空，什麼都不作
        // 只要你寫了一個下面的某一種構造函數，系統就不會再自動生成這樣一個默認的構造函數，若是但願有一個這樣的無參構造函數，則須要本身顯示地寫出來
        Complex(void)
        {
             m_real = 0.0;
             m_imag = 0.0;
        }  
        //    通常構造函數（也稱重載構造函數）
        // 通常構造函數能夠有各類參數形式,一個類能夠有多個通常構造函數，前提是參數的個數或者類型不一樣（基於c++的重載函數原理）
        // 例如：你還能夠寫一個 Complex( int num)的構造函數出來
        // 建立對象時根據傳入的參數不一樣調用不一樣的構造函數
      

 Complex(double real, double imag)
        {
             m_real = real;
             m_imag = imag;        
         }

        //    複製構造函數（也稱爲拷貝構造函數）
        //    複製構造函數參數爲類對象自己的引用，用於根據一個已存在的對象複製出一個新的該類的對象，通常在函數中會將已存在對象的數據成員的值複製一份到新建立的對象中
        //    若沒有顯示的寫複製構造函數，則系統會默認建立一個複製構造函數，但當類中有指針成員時，由系統默認建立該複製構造函數會存在風險，具體緣由請查詢有關「淺拷貝」、「深拷貝」的文章論述
spa

        Complex(const Complex & c)
        {
                // 將對象c中的數據成員值複製過來
                m_real = c.m_real;
                m_imag    = c.m_imag;
        }

// 類型轉換構造函數，根據一個指定的類型的對象建立一個本類的對象，
//須要注意的一點是，這個其實就是通常的構造函數，可是對於出現這種單參數的構造函數，C++會默認將參數對應的類型轉換爲該類類型，有時候這種隱私的轉換是咱們所不想要的，因此須要使用explicit來限制這種轉換。.net

// 例如：下面將根據一個double類型的對象建立了一個Complex對象

       Complex(double r)
        {
                m_real = r;
                m_imag = 0.0;
        }
        // 等號運算符重載（也叫賦值構造函數）
        // 注意，這個相似複製構造函數，將=右邊的本類對象的值複製給等號左邊的對象，它不屬於構造函數，等號左右兩邊的對象必須已經被建立
        // 若沒有顯示的寫=運算符重載，則系統也會建立一個默認的=運算符重載，只作一些基本的拷貝工做
        Complex &operator=( const Complex &rhs )
        {
                // 首先檢測等號右邊的是否就是左邊的對象自己，如果本對象自己,則直接返回
                if ( this == &rhs )
                {
                        return *this;
                }               
                // 複製等號右邊的成員到左邊的對象中
                this->m_real = rhs.m_real;
                this->m_imag = rhs.m_imag;               
               // 把等號左邊的對象再次傳出
               // 目的是爲了支持連等 eg:    a=b=c 系統首先運行 b=c
               // 而後運行 a= ( b=c的返回值,這裏應該是複製c值後的b對象)    
                return *this;
        }
};

下面使用上面定義的類對象來講明各個構造函數的用法：
設計

int main()
{
        // 調用了無參構造函數，數據成員初值被賦爲0.0
        Complex c1，c2;

        // 調用通常構造函數，數據成員初值被賦爲指定值
        Complex c3(1.0,2.5);
        // 也可使用下面的形式
        Complex c3 = Complex(1.0,2.5);
       
        //    把c3的數據成員的值賦值給c1
        //    因爲c1已經事先被建立，故此處不會調用任何構造函數
        //    只會調用 = 號運算符重載函數
        c1 = c3;       
        //    調用類型轉換構造函數
        //    系統首先調用類型轉換構造函數，將5.2建立爲一個本類的臨時對象，而後調用等號運算符重載，將該臨時對象賦值給c1
        c2 = 5.2;       
       // 調用拷貝構造函數( 有下面兩種調用方式)
        Complex c5(c2);
        Complex c4 = c2;  // 注意和 = 運算符重載區分,這裏等號左邊的對象不是事先已經建立，故須要調用拷貝構造函數，參數爲c2
//這一點特別重要，這兒是初始化，不是賦值。其實這兒就涉及了C++中的兩種初始化的方式：複製初始化和賦值初始化。其中c5採用的是複製初始化，而c4採用的是賦值初始化，這兩種方式都是要調用拷貝構造函數的。
}

3、思考與測驗
1. 仔細觀察複製構造函數
指針

  Complex(const Complex & c)
        {
                // 將對象c中的數據成員值複製過來
                m_real = c.m_real;
                m_img = c.m_img;
        }

爲何函數中能夠直接訪問對象c的私有成員？
答：（網上）由於拷貝構造函數是放在自己這個類裏的，而類中的函數能夠訪問這個類的對象的全部成員，固然包括私有成員了。
2. 挑戰題，瞭解引用與傳值的區別
code

  Complex test1(const Complex& c)
  {
          return c;
  }
   Complex test2(const Complex c)
  {
         return c;
   }
    Complex test3()
   {
          static Complex c(1.0,5.0);
          return c;
   }
   Complex& test4()
  {
         static Complex c(1.0,5.0);
         return c;
  } 
  void main()
  {
        Complex a,b;   
        // 下面函數執行過程當中各會調用幾回構造函數，調用的是什麼構造函數？   
       test1(a);
       test2(a);    
       b = test3();
       b = test4();    
       test2(1.2);
       // 下面這條語句會出錯嗎？
       test1(1.2);     //test1( Complex(1.2 )) 呢？
  }

答：爲了便於看構造函數的調用效果，我將類從新改一下，添加一些輸出信息，代碼以下：對象

View Code

下面是程序運行結果：第一次運行結果

第2次運行結果

第3次運行結果

4、附錄(淺拷貝與深拷貝)

上面提到，若是沒有自定義複製構造函數，則系統會建立默認的複製構造函數，但系統建立的默認複製構造函數只會執行「淺拷貝」，即將被拷貝對象的數據成員的值一一賦值給新建立的對象，若該類的數據成員中有指針成員，則會使得新的對象的指針所指向的地址與被拷貝對象的指針所指向的地址相同，delete該指針時則會致使兩次重複delete而出錯。下面是示例：
【淺拷貝與深拷貝】

  #include <iostream.h>
#include <string.h>
class Person
{
public :
         // 構造函數
        Person(char * pN)
        {
              cout << "通常構造函數被調用 !\n";
              m_pName = new char[strlen(pN) + 1];
              //在堆中開闢一個內存塊存放pN所指的字符串
              if(m_pName != NULL)
              {
                 //若是m_pName不是空指針，則把形參指針pN所指的字符串複製給它
                   strcpy(m_pName ,pN);
              }
        }        
       
        // 系統建立的默認複製構造函數，只作位模式拷貝
        Person(Person & p)    
        {
                  //使兩個字符串指針指向同一地址位置        
                 m_pName = p.m_pName;        
        }
         ~Person( )
        {
                delete m_pName;
        }
  private :

        char * m_pName;
};

void main( )
{
        Person man("lujun");
        Person woman(man);
       
        // 結果致使   man 和    woman 的指針都指向了同一個地址
       
        // 函數結束析構時
        // 同一個地址被delete兩次
}
// 下面本身設計複製構造函數，實現「深拷貝」，即不讓指針指向同一地址，而是從新申請一塊內存給新的對象的指針數據成員
Person(Person & chs);
{
         // 用運算符new爲新對象的指針數據成員分配空間
         m_pName=new char[strlen(p.m_pName)+ 1];

         if(m_pName)        
         {
                 // 複製內容
                strcpy(m_pName ,chs.m_pName);
         }
     
        // 則新建立的對象的m_pName與原對象chs的m_pName再也不指向同一地址了
}

下面討論一個重要問題是：構造函數的顯式調用

你們看看下面這段代碼的輸出結果是什麼？這段代碼有問題麼？

    #include <iostream>
     class CTest
    {
    public:
        CTest()
        {
            m_a = 1;
        }
        CTest(int b)
        {
            m_b = b;
            CTest();
        }
        ~CTest()
        {}
        void show
        {
            std::cout << m_a << std::endl;
            std::cout << m_b << std::endl;
        }
     private:
        int m_a;
        int m_b;
    };
   void main()
    {
        CTest myTest(2);
        myTest.show();
    }

-----------------------------------------------------------

【分析】
-----------------------------------------------------------

輸出結果中，m_a是一個不肯定的值，由於沒有被賦初值，m_b 爲2

注意下面這段代碼

CTest(int b)
{
    m_b = b;
    CTest();
}

在調用CTest()函數時，其實是建立了一個匿名的臨時CTest類對象，CTest()中賦值 m_a = 1 也是對該匿名對象賦值，故咱們定義的myTest的m_a其實沒有被賦值。說白了，其實構造函數並不像普通函數那樣進行一段處理，而是建立了一個對象，並且對該對象賦初值，因此顯式調用構造函數沒法實現給私有成員賦值的目的。

這個例子告訴咱們之後代碼中千萬不要出現使用一個構造函數顯式調用另一個構造函數，這樣會出現不肯定性。其實一些初始化的代碼能夠寫在一個單獨的init函數中，而後每個構造函數都調用一下該初始化函數就好了。

在此，順便再提出另一個問題以供思考:

    CTest *p = NULL;
     void func()
    {
        p = new CTest();
    }

代碼右邊顯示調用CTest()，是否依然會產生一個匿名的臨時對象a，而後將該匿名的臨時對象a的地址賦給指針p? 若是是這樣的話，出了func函數後，臨時對象a是否會被析構? 那指針p不成爲了野指針了？你能解釋這個問題麼？

答：我實驗的結果是不會產生臨時對象a，直接將產生的對象指針賦給了p