【C++修炼之路 第二章：类和对象 】下

1、再谈构造函数

首先先讲清楚 什么是真正的 默认构造函数？

默认构造是指：不用传参的构造函数（包括：无参构造、全缺省构造函数、自动生成的构造）

不具备默认构造：比如你自己写了一个 半缺省构造函数（刚好规避调默认构造函数的所有特点）

当类中的自定义类型不具备默认构造，这个类本身也无法给他生成默认构造

1.1 构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

class Date
{
   
    public:
    Date(int year, int month, int day)
    {
   
        _year = year;
        _month = month;
        _day = day;
    }

    private:
    int _year;
    int _month;
    int _day;
};

虽然上述构造函数调用之后，使对象中有了一个初始值，但是不能将其称为对对象中成员变量的初始化， 构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体 内可以多次赋值。

总结：

初始化概念：只能初始化一次

构造函数：可以多次赋值

因此构造函数第一次赋值，不能算作初始化（性质不一样）

真正的对象初始化：使用初始化列表

1.2 初始化列表

初始化 自定义类型，自定义类型会使用自己的构造函数进行赋值，内置类型直接赋值

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式

注意书写格式：冒号起手，逗号分隔

class Date
{
   
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{
   }

private:
	int _year;
	int _month;
	int _day;
};

初始化列表==本质可以理解为每个对象中成员定义的地方==，成员声明的地方是在 写类型和变量名的地方（为什么，问就是定义，别问（doge））

1.2.1 每个成员变量在初始化列表中只能出现一次（初始化只能初始化一次）

1.2.2 类中包含以下成员，必须放在初始化列表位置进行初始化：

• 引用成员变量
• const成员变量
• 自定义类型成员(且该类没有默认构造函数时)

⭐引用 和 const 都必须在定义的时候初始化，因此都必须写在初始化列表中（初始化列表==本质可以理解为每个对象中成员定义的地方==）

class Stack {
   
public:
	// ....
	Stack(int n) {
   }; // 带参无缺省构造函数（不是默认构造函数）
};

class MyQueue {
   
public:
	// 构造函数
	MyQueue(int n, int& d)
		:_pushSt(n)  // 自定义类型（没有默认构造函数的）
		, _popSt(n)
		,tmp1(n)     // const 类型
		,tmp2(d)    // 引用 类型
		, top(0)   
	{
   }

private:
	// 没有默认构造的两个自定义类型
	Stack _pushSt;
	Stack _popSt;
	const int tmp1;   // const 类型
	int& tmp2;     // 引用 类型
	int top;
};

int main()
{
   
	int d;
	MyQueue q(10, d);
	return 0;
}

1.2.3 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使 用初始化列表初始化（这个是优先进行的，那你还不如直接使用这个）。

⭐成员变量的缺省值是为 初始化列表服务的

​ 当你没有显式写初始化列表时，就会使用缺省值初始化（就跟函数参数处的缺省值一样，你不传参，就使用缺省值，这里也同理，成员变量的缺省值和初始化列表匹配）

初始化列表的传递的初始化值是比较自由的，就像函数传参一样

可以传一个函数返回值、传malloc开的空间……

class MyQueue {
   
public:
    // 构造函数
    MyQueue(int n, int& d)
        :a((int*)malloc(sizeof(int) * 8))     // 传malloc开的空间
        ,tmp(func())    // 传一个函数返回值
        {
   }
private:
    int *a;   // const 类型
    int tmp;     // 引用 类型
};

⭐总结的精华：

初始化列表，不管你写不写，每个成员变量都会先走一遍

• 自定义类型的成员会调用默认构造（没有默认构造就编译报错）
• 内置类型：你初始化列表处初始化了就没事，如果不写初始化列表，则有缺省值用缺省值，没有的话，不确定，要看编译器，有的编译器会处理，有的不会处理
• 先走初始化列表 +再走函数体
• 实践中，尽可能的使用初始化列表初始化，不方便再使用函数体初始化

不方便的情况一般是需要对初始值进一步处理的：如将 malloc 的空间都初始化成 0

class MyQueue {
   
public:
    // 构造函数
    MyQueue(int n, int& d)
        :_a((int*)malloc(sizeof(int) * 8))     // 传malloc开的空间
        ,_tmp(func())    // 传一个函数返回值
        {
   
            malloc(__a, 0, sizeof(int) * 8));  // 空间中数值都初始化成 1
        }
private:
    int *_a;   // const 类型
    int _tmp;     // 引用 类型
};

const 是在定义的时候 赋初始值，在定义之后就不能改了

因此在初始化列表处，const 定义赋初值

同时，const 类型的变量，要么直接在初始化列表定义赋初值，要么给缺省值（这个本质也是为初始化列表服务的）

1.2.4 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关（很容易错的一点，笔试题）

class A
{
   
public:
	A(int a)
		:_a1(a)
		, _a2(_a1)
	{
   }

	void Print() {
   
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2