[cpp deep dive] 初始化initialization

我實在不喜歡糾結(jié)于語法，然而這些面試又很喜歡考。（我自己也很好奇到底真相是什么）
[Update 9.10]
====
總結(jié)一些關(guān)鍵點：
int *p = new int; - 默認初始化， 隨機值.
int *p = new int(); - 值初始化，賦成0.

[Update 9.6]看起來官方一點的說法（常見用法，不嚴(yán)謹）

按照ref, 初始化有n種大類：

  • 默認初始化（default initialization）

    • 例如：T x; new T;

    • 什么時候發(fā)生：

      1. 局部變量沒有提供initializer時,(沒有括號)
      2. 動態(tài)申請變量（通過new），沒有提供initializer時,(沒有括號)
      3. 在類的構(gòu)造列表中沒有提到時,

    • 會有什么效果：

      1. non-POD 類型的，會調(diào)用其默認構(gòu)造函數(shù)（沒有參數(shù)列表的構(gòu)造函數(shù)）
      2. 若該對象是一個數(shù)組類型，則數(shù)組內(nèi)所有對象都會默認初始化.
      3. POD類型的，則除了分配給變量空間則什么都不做.局部變量就會有不確定的值；

      （若是static或者全局對象，在整個程序進入main之前就已初始化（g++是零初始化），這里則什么都不做）

    注：局部變量（對象）就是自動存儲變量.the objects with automatic storage duration

  • 直接初始化（direct initialization）
    我覺得就是形式上根據(jù)重載, 直接調(diào)用了某個構(gòu)造函數(shù).

  • 復(fù)制初始化（copy initialization）

    • 舉例： T x = <expr>;
    • 什么時候發(fā)生：
      • 類似于T x = <expr>;這樣定義一個對象.
      • 函數(shù)參數(shù)的值傳遞形式
      • 函數(shù)返回值的值傳遞形式
    • 效果：
      • 如果是類，且expr的值類型與T一致，復(fù)制構(gòu)造函數(shù)就會被調(diào)用.
      • 如果是類，且expr的值類型與T不一致， 會試圖通過合適的構(gòu)造函數(shù)生成一個臨時變量，并通過該臨時變量復(fù)制構(gòu)造x.(overhead - 1個臨時變量 + 2次構(gòu)造函數(shù)調(diào)用，在實現(xiàn)上可能會有相應(yīng)的編譯器優(yōu)化，例如RVO、-fno-elide-constructors等)
      • 如果不是類，則會試圖進行類型轉(zhuǎn)換.

  • 值初始化（value initialization）

    • 什么時候發(fā)生：簡單地說就是加了一對空括號.T* x = new T(); T x = T();
    • 效果：簡單地說就是類類型的，會調(diào)用默認構(gòu)造函數(shù)，非類類型的，則會被零初始化.
stage_0 基本類型（或內(nèi)建類型 build-in type）.

簡單粗暴地說就是：

  • 沒有用戶指定初始化時（e.g. int x;，簡單地說就是沒有括號）

    • 局部變量 - 隨機值；
    • 全局變量 - 0；

  • 有用戶指定初始化時

    • 用戶提供的值；（e.g. int x = <num>; / int x(<num>);/ int x = int(<num>);）
    • 假如用戶沒有提供值，就是0；（e.g. int x();/ int x=int();）<-----------int x();實際上是一個函數(shù)的聲明，x的值是函數(shù)的地址.

  • 需要注意的是，POD類型（例如int）沒有構(gòu)造函數(shù)，它只是看起來很像有構(gòu)造函數(shù)而已.

  • 對于new關(guān)鍵字，也是與上面的相同，（7.24更新，不是與上面的相同，new所申請的空間在于堆，是否初始化在于用戶是否指定了初始化的值;malloc同樣也是沒有初始化的(另外new實際上是通過malloc實現(xiàn)的，與之相對應(yīng)的是calloc就有初始化成0).）

    • 用戶沒有指定初始化時, 簡單滴說就是沒有括號:（只分配動態(tài)空間，不負責(zé)初始化）
      • 隨機值;
    • 用戶指定初始化時:
      • 0或者用戶指定的數(shù).

  • 參考：
    c++_standard
    關(guān)于POD類型沒有構(gòu)造函數(shù)的可以看這個thread：<a href = http://stackoverflow.com/questions/5113365/do-built-in-types-have-default-constructors>do-built-in-types-have-default-constructors</a>

stage_1 類類型的初始化. （類類型成員變量的初始化）

  • 初始化列表

    • 類成員的初始化是在構(gòu)造函數(shù)的初始化列表中進行的;
    • 類成員的初始化嚴(yán)格按照聲明的順序進行（而非初始化列表中的順序）;
    • 類構(gòu)造函數(shù)中如果有賦值的，那么初始化在其賦值前已經(jīng)完成.
    • 若被調(diào)用的構(gòu)造函數(shù)沒有初始化列表，則會對內(nèi)部成員進行自動初始化，規(guī)則就是局部變量初始化為隨機值（只分配空間不賦給初值），全局變量會被零-初始化.

  • 類在被聲明時，它的某個構(gòu)造函數(shù)一定會被調(diào)用.

  • situation_01 如果沒有構(gòu)造函數(shù)怎么辦？

    • 如果用戶沒有定義任何構(gòu)造函數(shù)，編譯器自動生成一個默認構(gòu)造函數(shù).
    • 該默認構(gòu)造函數(shù)沒有初始化列表，也沒有在函數(shù)體內(nèi)部對成員進行賦值.
    • 因此會進行自動初始化.

  • 編譯器到底替我們生成了什么毛??？

    (effective c++ 條款5)在有用到的情況下，會自動生成以下：默認構(gòu)造函數(shù)（假如用戶沒有定義任何構(gòu)造函數(shù)），復(fù)制構(gòu)造函數(shù)，析構(gòu)函數(shù)，賦值構(gòu)造操作符.
    這個也是個大坑, 改天專門討論 這里我們專心搞初始化.

代碼片段
//initialization.cc
#include <iostream>
#include <cstdio>
using namespace std;
int x;
float y;
#define ___(str) cout<<"====="<<str<<"===="<<endl;

int make_dirty(){
    double gg=12354.3453765;
    double gg2=12354.3453765;
    double gg3=12354.3453765;
    return 0;
}
/*
int l(){
    return 100;
}
*/

//stage_0
int test1(){

    ___("===global variable ===");
    cout<<x<<endl;//0
    cout<<y<<endl;//0
    

    ___("===local variable default init=====");
    int k;
    double g;
    cout<<k<<endl;//random
    cout<<g<<endl;//random
    

    ___("===local variable explicit user-specified init=====");
    int c = 8;//8,c-style-initial
    //int l();//0
    int ll = int();//0
    int ll2= int(3);//3 /*act like a constructor*/
    cout<<c<<endl;
    //cout<<l<<endl;
    //printf("l -- %p\n", l);
    cout<<ll<<endl;
    cout<<ll2<<endl;
    
    
    ___("===dynamic variable with new_operator=====");
    /*make it dirty at first.*/
    int *tmp=new int[1000];
    for(int i=0;i<1000;i++){
        tmp[i]=(i+0xfecb) % 1009;
    }
    delete[] tmp;
    
    
    int* ll3= new int;//random 
    int* ll4= new int(5);//5
    int* ll5= new int();//0
    cout<<*ll3<<endl;
    cout<<*ll4<<endl;
    cout<<*ll5<<endl;
    return 0;
}

class base1{
public:
    base1(){
        
    }
    base1(int x1) : x(x1) , y(0) , z(10){
        
    } 
    base1(float x1) : z((int)x1), y(z) , x(z){
        
    }
    base1(double x1) : x((int)x1){
        ___("in base1(double)");
        cout<<x<<endl<<y<<endl<<z<<endl;
        y = z = x;
    }
    void f(){
        cout<<x<<endl<<y<<endl<<z<<endl;
    }
private:
    int x;
    int y;
    int z;
};

base1 b2_1((float)11);

void test2(){
    ___("with initialization list");
    base1 b1_2(11);
    b1_2.f();
    
    ___("initialization list's init order");//will be initialized in the declaration order.
    base1 b1_3((float)11);
    b1_3.f();

    ___("without initialization list");
    base1 b1_1;
    b1_1.f();
    
    ___("initialization list not include y&z");
    base1 b1_4(double(11));
    b1_4.f();
    
    ___("global auto-zero-init");
    b2_1.f();
}


int main(){
    cout<<"build-in type"<<endl;
    make_dirty();
    test1();
    
    cout<<"user-defined type(class)"<<endl;
    test2();
}

運行結(jié)果.

root@vm1:/home/work/share/CSE274/02_Cpp_Intro# g++ initialization.cc -o test
root@vm1:/home/work/share/CSE274/02_Cpp_Intro# ./test 
build-in type
========global variable =======
0
0
========local variable default init=========
-782730784
4.94066e-323
========local variable explicit user-specified init=========
8
0
3
========dynamic variable with new_operator=========
651
5
0
user-defined type(class)
=====with initialization list====
11
0
10
=====initialization list's init order====
6299808
6299808
11
=====without initialization list====
-782736384
32607
-786215278
=====initialization list not include y&z====
=====in base1(double)====
11
0
-782106642
11
11
11
=====global auto-zero-init====
0
0
11
stage 2 初始化列表2點深入.
  • 什么時候必須使用初始化列表
    • 成員為const或引用類型 （因為他們有個特點就是必須在聲明時初始化，這個譚浩強已經(jīng)說的很清楚了）
    • 成員沒有默認構(gòu)造函數(shù)（因為這里如果不用初始化列表-->則進行默認的初始化-->默認初始化調(diào)用默認構(gòu)造函數(shù)）
#include <iostream>
#include <cstdio>
using namespace std;
#define ___(str) cout<<"====="<<str<<"===="<<endl;
class b{
    b(int x):k(x){}
    int k;
};


class base1{
    base1(){}
private:
    const int cc;
    int& ccr;
    b yhb;
};

int main(){
    //const int x;
    //int &y;
    /*
     *  initialization2.cc: In function ‘int main()’:
        initialization2.cc:11:12: error: uninitialized const ‘x’ [-fpermissive]
          const int x;
                    ^
        initialization2.cc:12:7: error: ‘y’ declared as reference but not initialized
          int &y;

     */
    //base1 bb_1;
     /*
      * root@vm1:/home/work/share/CSE274/02_Cpp_Intro# g++ initialization2.cc -o test
        initialization2.cc: In constructor ‘base1::base1()’:
        initialization2.cc:12:2: error: uninitialized member ‘base1::cc’ with ‘const’ type ‘const int’ [-fpermissive]
          base1(){}
          ^
        initialization2.cc:12:2: error: uninitialized reference member ‘base1::ccr’ [-fpermissive]
        initialization2.cc:12:9: error: no matching function for call to ‘b::b()’
          base1(){}
                 ^
        initialization2.cc:12:9: note: candidates are:
        initialization2.cc:6:2: note: b::b(int)
          b(int x):k(x){}
          ^
        initialization2.cc:6:2: note:   candidate expects 1 argument, 0 provided
        initialization2.cc:5:7: note: b::b(const b&)
         class b{
               ^
        initialization2.cc:5:7: note:   candidate expects 1 argument, 0 provided
        initialization2.cc: In function ‘int main()’:
        initialization2.cc:12:2: error: ‘base1::base1()’ is private
          base1(){}
          ^
        initialization2.cc:31:9: error: within this context
           base1 bb_1;
                 ^

      */
     
    return 0;
}

todo：

  • 利用初始化列表給成員初始化和在構(gòu)造函數(shù)內(nèi)部進行賦值有什么差別呢？
    先上結(jié)論 - 結(jié)果大家都一樣的，差在性能.
  • malloc出來的buffer空間內(nèi)容是否是0呢？(猜想 - 應(yīng)該與new出來的動態(tài)空間規(guī)則一致)
    malloc申請的空間是未經(jīng)初始化的堆內(nèi)存，
    calloc申請的空間是經(jīng)過初始化的堆內(nèi)存.
  • 初始化一個數(shù)組的流程是什么呢？
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

  • importUIKit classViewController:UITabBarController{ enumD...
    明哥_Young閱讀 4,188評論 1贊 10
  • Spring Cloud為開發(fā)人員提供了快速構(gòu)建分布式系統(tǒng)中一些常見模式的工具（例如配置管理，服務(wù)發(fā)現(xiàn)，斷路器，智...
    卡卡羅2017閱讀 136,536評論 19贊 139
  • 123.繼承 一個類可以從另外一個類繼承方法,屬性和其他特征。當(dāng)一個類繼承另外一個類時, 繼承類叫子類, 被繼承的...
    無灃閱讀 1,490評論 2贊 4
  • 前言 人生苦多，快來 Kotlin ，快速學(xué)習(xí)Kotlin！ 什么是Kotlin？ Kotlin 是種靜態(tài)類型編程...
    任半生囂狂閱讀 26,686評論 9贊 118
  • 話說，活了28年，我還沒怎么學(xué)會好好地照顧我自己?；榍坝邪謰?，婚后有婆婆。自從婆婆搬來和我們一起住后我?guī)缀鯖]怎么做...
    俊guaiguai閱讀 1,048評論 2贊 1

友情鏈接更多精彩內(nèi)容