我实在不喜欢纠结于语法，然而这些面试又很喜欢考。（我自己也很好奇到底真相是什么）
[Update 9.10]
====
总结一些关键点：
int *p = new int; - 默认初始化， 随机值.
int *p = new int(); - 值初始化，赋成0.

[Update 9.6]看起来官方一点的说法（常见用法，不严谨）

按照ref, 初始化有n种大类：

• 默认初始化（default initialization）

  • 例如：T x; new T;

  • 什么时候发生：

    1. 局部变量没有提供initializer时,(没有括号)
    2. 动态申请变量（通过new），没有提供initializer时,(没有括号)
    3. 在类的构造列表中没有提到时,

  • 会有什么效果：

    1. non-POD 类型的，会调用其默认构造函数（没有参数列表的构造函数）
    2. 若该对象是一个数组类型，则数组内所有对象都会默认初始化.
    3. POD类型的，则除了分配给变量空间则什么都不做.局部变量就会有不确定的值；

    （若是static或者全局对象，在整个程序进入main之前就已初始化（g++是零初始化），这里则什么都不做）

  注：局部变量（对象）就是自动存储变量.the objects with automatic storage duration

• 直接初始化（direct initialization）
  我觉得就是形式上根据重载, 直接调用了某个构造函数.

• 复制初始化（copy initialization）

  • 举例： T x = <expr>;
  • 什么时候发生：
    • 类似于T x = <expr>;这样定义一个对象.
    • 函数参数的值传递形式
    • 函数返回值的值传递形式
  • 效果：
    • 如果是类，且expr的值类型与T一致，复制构造函数就会被调用.
    • 如果是类，且expr的值类型与T不一致， 会试图通过合适的构造函数生成一个临时变量，并通过该临时变量复制构造x.(overhead - 1个临时变量 + 2次构造函数调用，在实现上可能会有相应的编译器优化，例如RVO、-fno-elide-constructors等)
    • 如果不是类，则会试图进行类型转换.

• 值初始化（value initialization）

  • 什么时候发生：简单地说就是加了一对空括号.T* x = new T(); T x = T();
  • 效果：简单地说就是类类型的，会调用默认构造函数，非类类型的，则会被零初始化.

stage_0 基本类型（或内建类型 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();实际上是一个函数的声明，x的值是函数的地址.

• 需要注意的是，POD类型（例如int）没有构造函数，它只是看起来很像有构造函数而已.

• 对于new关键字，也是与上面的相同，（7.24更新，不是与上面的相同，new所申请的空间在于堆，是否初始化在于用户是否指定了初始化的值;malloc同样也是没有初始化的(另外new实际上是通过malloc实现的，与之相对应的是calloc就有初始化成0).）

  • 用户没有指定初始化时, 简单滴说就是没有括号:（只分配动态空间，不负责初始化）
    • 随机值;
  • 用户指定初始化时:
    • 0或者用户指定的数.

• 参考：
  c++_standard
  关于POD类型没有构造函数的可以看这个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 类类型的初始化. （类类型成员变量的初始化）

• 初始化列表

  • 类成员的初始化是在构造函数的初始化列表中进行的;
  • 类成员的初始化严格按照声明的顺序进行（而非初始化列表中的顺序）;
  • 类构造函数中如果有赋值的，那么初始化在其赋值前已经完成.
  • 若被调用的构造函数没有初始化列表，则会对内部成员进行自动初始化，规则就是局部变量初始化为随机值（只分配空间不赋给初值），全局变量会被零-初始化.

• 类在被声明时，它的某个构造函数一定会被调用.

• situation_01 如果没有构造函数怎么办？

  • 如果用户没有定义任何构造函数，编译器自动生成一个默认构造函数.
  • 该默认构造函数没有初始化列表，也没有在函数体内部对成员进行赋值.
  • 因此会进行自动初始化.

• 编译器到底替我们生成了什么毛啊？

  (effective c++ 条款5)在有用到的情况下，会自动生成以下：默认构造函数（假如用户没有定义任何构造函数），复制构造函数，析构函数，赋值构造操作符.
  这个也是个大坑, 改天专门讨论 这里我们专心搞初始化.

代码片段

//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();
}

运行结果.

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或引用类型 （因为他们有个特点就是必须在声明时初始化，这个谭浩强已经说的很清楚了）
  • 成员没有默认构造函数（因为这里如果不用初始化列表-->则进行默认的初始化-->默认初始化调用默认构造函数）

#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：

• 利用初始化列表给成员初始化和在构造函数内部进行赋值有什么差别呢？
  先上结论 - 结果大家都一样的，差在性能.
• malloc出来的buffer空间内容是否是0呢？(猜想 - 应该与new出来的动态空间规则一致)
  malloc申请的空间是未经初始化的堆内存，
  calloc申请的空间是经过初始化的堆内存.
• 初始化一个数组的流程是什么呢？