一、默认构造函数

1.1 什么是默认构造函数？

我们一般会认为默认构造函数就是编译器自动生成的那个构造函数，其实这种理解不全面。
准确的说，默认构造函数就是在调用时不需要显示地传入实参的构造函数。根据这个原则，下面 2 种构造函数都是默认构造函数：

class Sample {
public:
  // 默认构造函数。
  Sample() {
    // do something
  }
};

class Sample {
public:
  // 默认构造函数。虽然有形参，但有默认值，调用的时候可以不显示的传入实参。
  Sample(int m = 10) {
    // do something
  }
};

1.2 默认构造函数调用时机

如果定义一个对象时没有使用初始化式，编译器就会使用默认构造函数。如：

Sample s;

1.3 编译器何时生成默认构造函数

有一句很经典的话可以用来回答这个问题：惟有默认构造函数”被编译器需要“的时候，编译器才会生成默认构造函数。

那我们只需知道什么时候“被编译器需要”，就可以知道什么情况下会生成默认构造函数了。下面几种情况下，编译需要生成默认构造函数：

当该类的类对象数据成员有默认构造函数时。
当该类的基类有默认构造函数时。
当该类的基类为虚基类时。
当该类有虚函数时。

1.4 注意事项

1. 避免“无参数的默认构造函数”和“带缺省参数的默认构造函数”同时存在

无参数的默认构造函数和带缺省参数的默认构造函数同时存在时，编译器会产生二义性，从而生成编译错误。

class Sample {
public:
  // 默认构造函数
  Sample() {
    // do something
    printf("Sample()");
  }

  // 默认构造函数
  Sample(int m = 10) {
    // do something
    printf("Sample(int m = 10)");
  }
};


int main()
{
  Sample s; // error C2668: “Sample::Sample”: 对重载函数的调用不明确

    return 0;
}

2. 使用无参构造函数创建对象时，不应在对象名后面加上括号

使用无参构造函数创建对象时，不应在对象名后面加上括号，否则会产生编译警告“warning C4930: “Sample s(void)”: 未调用原型函数(是否是有意用变量定义的?)”。因为编译器误认为Sample s();语句时要声明返回值为Sample对象的函数s，而又没找到函数s的定义，所以产生了警告。

class Sample {
public:
  // 默认构造函数
  Sample() {
    // do something
    printf("Sample()");
  }
};


int main()
{
  Sample s(); // warning C4930: “Sample s(void)”: 未调用原型函数(是否是有意用变量定义的?)

    return 0;
}

二、构造函数初始化列表

2.1 何为构造函数初始化列表

class Sample {
public:
  // 构造函数内部赋值
  Sample(int a)  {
    a_ = a;
  }

  // 构造函数初始化列表
  Sample(int a) : a_(a) {

  }
private:
  int a_;
};

上面的代码中，Sample类的 2 个构造函数的功能是一样的，都是初始化成员变量a_，区别在于一个采用的是构造函数内部赋值的方式来初始化的，另一个采用的是构造函数初始化列表初始化列表的方式来初始化的。

2.1 何时必须使用初始化列表

如果按照上面所说的，既然 2 种初始化成员变量的方式所起得作用是一样的，那么在哪些情况下必须使用构造函数初始化列表的了？
下面 2 种情况的成员变量必须使用构造函数初始化列表的方式来初始化：

成员变量是 const 常量。
成员变量是引用类型。

下面例子演示了成员变量是const常量和引用类型时，如何初始化它们：

class Sample {
public:
  Sample() : kCount(11), name_(std::string("jeff"))  {

  }
private:
  std::string &name_;
  const int kCount;
};

2.3 初始化列表的顺序问题

使用构造函数初始化列表进行成员变量初始化时，要注意成员变量的初始化顺序。
举个例子来说明，现有类SeqSample有 3 个成员变量a_, b_, c_，构造函数被设计为将a_, b_, c_都初始化为m，也就是a_ == b_ == c_ == m：

class SeqSample {
public:
  SeqSample(int m) :
    a_(m),
    b_(a_),
    c_(b_)
  {

  }

private:
  int b_;
  int a_;
  int c_;
};

int main()
{
  SeqSample ss(1);
    return 0;
}

通过调试器观察到执行构造函数初始化之后，成员变量a_, b_, c_的值分别为：

1
2
3

b_ = -858993460
a_ = 1
c_ = -858993460

而不是我们期望的a_ = 1 b_ = 1 c_ = 1。

出现这种问题的原因在于：编译器对构造函数初始化列表中的变量进行初始化的时候，不是按照变量初始化列表中的顺序来进行初始化的，而是按照变量在类中的声明顺序来初始化的。

所以，在初始化列表中的变量有依赖关系时（如上面的b_依赖于a_的初始化结果），要特别注意这种情况。

2.4 初始化列表的另一个好处

先模糊的把这个好处说出来，不太明白的，可以看下面的示例：
若成员变量是类对象，则使用构造函数的初始化列表可以减少一次默认构造函数的调用。

测试代码如下（声明了一个Apple类，一个Test类，Test 类中有 2 个 Apple 对象apple1_, apple2_，唯一不同的是，apple1_通过初始化列表来初始化，apple2_通过函数体中的赋值语句来初始化）：

class Apple {
public:
  Apple() {
    printf("默认构造函数\n");
  }

  Apple(const Apple &that) {
    printf("复制构造函数\n");
  }

  Apple& operator = (const Apple&that) {
    printf("赋值运算符重载\n");
    return *this;
  }
};

class Test {
public:
  Test(const Apple &apple) : apple1_(apple) {
    apple2_ = apple;
  }
private:
  Apple apple1_;
  Apple apple2_;
};


int main()
{
  Apple apple;
  Test t(apple);
    return 0;
}

运行结果：

默认构造函数
复制构造函数
默认构造函数
赋值运算符重载

4 行输出分别由不同的语句产生，如图：

apple1_(apple)直接执行的复制构造函数，所以只产生一行输出；
而apple2_ = apple;却是先使用默认构造函数构造了一个 apple2对象，然后再通过赋值运算符将 apple 的内容更新到 apple2中，所以产生了 2 行输出。

2.5 构造函数初始化列表的异常捕获

构造的函数的初始化列表也可以使用异常捕获，具体使用方式如下：

class Foo {
public:
  Foo::Foo(int n)
    try :size(n), array(new int[n]) {
    //...
  }
  catch (const std::bad_alloc& e) {
    printf("%s\n", e.what());
  }
private:
  int size;
  int *array;
};