默认构造函数

什么是默认构造函数？

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

1
2
3
4
5
6
7

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

1
2
3
4
5
6
7

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

默认构造函数调用时机

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

1

Sample s;

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

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

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

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

注意事项

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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的定义，所以产生了警告。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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


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

    return 0;
}

构造函数初始化列表

何为构造函数初始化列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

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

	}
private:
	int a_;
};

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

何时必须使用初始化列表

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

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

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

1
2
3
4
5
6
7
8
9

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

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

初始化列表的顺序问题

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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_的初始化结果），要特别注意这种情况。

初始化列表的另一个好处

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

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;
}

运行结果：

1
2
3
4

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

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13

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;
};