建構式和解構式

目錄

• 頁面
• 問題
• 建構式與解構式
  • 初始化串列
  • 轉換構造
  • 拷貝構造（這種都是淺拷貝，每一項成員依次拷貝過去）
  • 默認的賦值運算子
  • 小的總結

頁面

構造/和解構式

問題

編譯器為什么要求拷貝構造為什么要傳參考？

如果存在兩個 同型別的物件A a, b ,如果將a 拷貝給 b ，實際上call b類的拷貝構造，b物件的拷貝物件是如果是非參考形式，以 a() 實參, （A const A a)形參 ，這時是同一型別，他又回去call 形參的拷貝構造，形參還是（A const A a)形參 ，實參又去形參的拷貝構造 ，套娃，，，

Int & 不能拷貝給匿名物件上的

為什么要const A &a (45 被bind 后是沒有系結匿名物件上的，const 是為兼容bind 到匿名物件的 )

做一個邏輯上的常量限制，（從邏輯上是不允許被拷貝物件被修改的）

兼容const型別的拷貝 不允許直接吧const 型別的變數直接傳到址非const的參考, 因為非const 是可以修改的，

建構式與解構式

每個物件創建時，一定call 建構式，當然銷毀也一定會調析構，

class Data{
public :
    Data() {
        cout << "default " << endl;
    }   
    int  x(){return __x;}; 
    int  y(){return __y;};

    ~Data(){
        cout  << "Free" <<endl;
    }   
private :
    int __x,__y;
};

int main(){
    Data dt; 
    cout <<dt.x() << dt.y() <<endl;                                                
    return 0;
}
// outoput 
//default 
//41969760
//Free

初始化串列

（初始化類中的成員）

初始化串列的順序，和類中屬性，宣告的順序有關系，而不是由初始化串列的順序決定，

最終的意義就是→初始化每一個屬性的行為，

按照約定，如果建構式初始化完成所有的初始化串列 ，意味每個成員物件的屬性已經初始化結束，

class A{
public :
    A(){} // 一旦有帶引數的構造器,如果沒有呼叫按照規則呼叫建構式的參樹，則會報錯 
    A(int x):x(x){
        cout << "Class A:" << x  <<endl;
    }   
    int x ; 
};

class Data{
public :
    // 接在建構式后面  : 初始串列（初始化成員）
    //顯示性的呼叫 A的建構式
    Data():__x(10),__y(0),a(34) {
        cout << "default " << endl;
    }   
    int  x(){return __x;}; 
    int  y(){return __y;};

    ~Data(){
        cout  << "Free" <<endl;
    }   
private :                                                                          
    int __x,__y;
    A a;
};

轉換構造

一個引數建構式又轉換構造

這個賦值運算可以看做 將int轉到A型別的物件,整形轉換為一個A型別的物件.

class A{
  public :
      A(){} // 一旦有帶引數的構造器,如果沒有呼叫按照規則呼叫建構式的參樹，則會報錯 需要顯示指出構>      A(int x):x(x){
          cout << "Class A:" << x  <<endl;
      } 
      int x ;
 };
 int main(
   A s(45);   
   A x =41; 
   return
 )
 
//0x7fff1a506a40  Class A:45
// addressof a :0x7fff1a506a40

拷貝構造（這種都是淺拷貝，每一項成員依次拷貝過去）

系統會自動添加拷貝構造，即使沒有宣告拷貝構造.在呼叫時，也會依次呼叫

?g++ -fno-elide-constructors 建構式回傳值優化 編譯時需要帶上引數才能編譯出

class A{
public :
    A(){
        cout << " default" << endl;
    } // 一旦有帶引數的構造器,如果沒有呼叫按照規則呼叫建構式的參樹，則會報錯 需要顯示指出建構式
    A(int x):x(x){
        cout << this << "  Class A:" << x  <<endl;
    }   
    A(const A &a){
        //拷貝構造
        cout << this << "   :copy A" << &a <<endl; 
    }   
    int x ; 
};

 A a=45;
 cout << "addressof a :" <<  &a <<endl;

0x7ffcfaaf6380  Class A:45
0x7ffcfaaf6370   :copy  from A0x7ffcfaaf6380
addressof a :0x7ffcfaaf6370

第一行:呼叫為6380 的有參構造 ,這個小a的地址為 6370,也就是說這個0x7ffcfaaf6380 并非調的小a的有參構造

第二行，在呼叫第一行的有參建構式后，第二行也會默認執行拷貝構造 ，將f6370拷貝給小a

?首先這個**45 **會通過轉換構造 去轉換成一個匿名物件,匿名的物件為這個f6380物件,然后再將匿名的a物件拷貝6370物件

默認的賦值運算子

當賦值運算子出現的時候,起始出現的是拷貝構造 ，因為 這個a 還沒宣告好，所以使用的是拷貝構造，

而下面的而賦值運算子在賦值時，a 物件已經準備好了

class A{
public :
    A(){
        cout << " default" << endl;
    } // 一旦有帶引數的構造器,如果沒有呼叫按照規則呼叫建構式的參樹，則會報錯 需要顯示指出建構式
    A(int x):x(x){
        cout << this << "  Class A:" << x  << endl;
    } 
    A(const A &a){
        //拷貝構造
        cout << this << "   :copy A" << &a << endl; 
    }
    void operator=(const A &a){
        cout << this << "assign from " << &a << endl;
    }
    int x ;
};
0x7ffef092db80  Class A:45
0x7ffef092db70   :copy from  A0x7ffef092db80
addressof a :0x7ffef092db70
0x7ffef092db90  Class A:78
0x7ffef092db70   assign from 0x7ffef092db90

int main(){
   A a = 45;
   cout << "addressof a :" <<  &a <<endl;
   a  =  78 ; //這個= 是相當于是call賦值運算子
   return 0;
 }

db80 通過轉換構造 構造的物件 db90 也通過轉換構造 構造的物件 （匿名的物件）

這個a的物件為 db70 通過 db80 拷貝過來 || 而這個db90 是通過賦值運算子賦值給 db70的

小的總結

A a = 78 由于這里的等號 ，一定call 調了拷貝構造 (而拷貝的出現的形式，是用的A型別的參考，這時會將45的引數（它本就不是a型別的值）. 這時會通過轉換構造，將45轉換為匿名的臨時物件,然后系結到這個const A &a 的參考上)

a = 78 ; //這里就很明顯，就調了 賦值運算子 (const A &a),后續程序一致，

標籤：其他

上一篇：Qt 學習筆記 - 第五章 - Qt 時間編程 - Qt 時鐘

下一篇：java介面學習筆記