C++ 类的初始化列表

        C++ 中的类必须使用初始化列表的 4 种情况：

一，继承于一个基类，这个基类的构造函数有参数时。

#include <stdio.h>
#include <stdlib.h>

#pragma pack(4)
class CBase
{
public:
	CBase(int value): bBaseValue(value)
	{

	}
	~CBase()
	{}

private:
	int bBaseValue;
};

class CTest: public CBase
{
public:
	CTest()
	{
		
	}
	~CTest()
	{
		
	}

private:
	int mValue;
};
#pragma pack()

int main()
{
	CTest test;
	printf("sizeof CTest is %llu\n", sizeof(test));
	return 0;
}

编译错误就是没有找到匹配的基类构造函数，因为没有显式的调用带参数的基类构造函数，所以只能在派生类的初始化列表里显式调用：

class CTest: public CBase
{
public:
	CTest(): CBase(200)
	{
		
	}
	~CTest()
	{
		
	}

private:
	int mValue;
};

二，有一个或多个对象成员，而这些对象成员的构造函数有参数时。

#include <stdio.h>
#include <stdlib.h>

#pragma pack(4)
class A
{
public:
	A(int a)
	{
		
	}
	~A()
	{
		
	}
};
class CTest
{
public:
	CTest()
	{
		
	}
	~CTest()
	{
		
	}

private:
	int mValue;
	A mA;
};
#pragma pack()

int main()
{
	CTest test;
	printf("sizeof CTest is %llu\n", sizeof(test));
	return 0;
}

这种情况跟上面的类似，都需要显式地调用带参数的构造函数，否则编译错误：

需要显式调用成员对象的构造函数：

class CTest
{
public:
	CTest(): mA(10)
	{
		
	}
	~CTest()
	{
		
	}

private:
	int mValue;
	A mA;
};

三， 当定义有 const 成员变量时

#include <stdio.h>
#include <stdlib.h>

#pragma pack(4)

class CTest
{
public:
	CTest()
	{
		
	}
	~CTest()
	{
		
	}

private:
	const int mValue;
};
#pragma pack()

int main()
{
	CTest test;
	printf("sizeof CTest is %llu\n", sizeof(test));
	return 0;
}

因为 const 类型的变量是常量，必须有初始化值，且后续不可以进行修改操作。 

#include <stdio.h>
#include <stdlib.h>

#pragma pack(4)

class CTest
{
public:
	CTest(): mValue(2)
	{
		
	}
	~CTest()
	{
		
	}

private:
	const int mValue;
};
#pragma pack()

int main()
{
	CTest test;
	printf("sizeof CTest is %llu\n", sizeof(test));
	return 0;
}

四，当定义有引用成员变量时

#include <stdio.h>
#include <stdlib.h>

#pragma pack(4)

class CTest
{
public:
	CTest(): mValue(2)
	{
		
	}
	~CTest()
	{
		
	}

private:
	const int mValue;
	int &mReference;
};
#pragma pack()

int main()
{
	CTest test();
	printf("sizeof CTest is %llu\n", sizeof(test));
	return 0;
}

和上面的错误一样，引用类型的变量必须初始化。

#include <stdio.h>
#include <stdlib.h>

#pragma pack(4)

class CTest
{
public:
	CTest(int a): mValue(2), mReference(a)//这样引用会有问题，这里只是为了说明初始化列表作为例子
	{
		
	}
	~CTest()
	{
		
	}

private:
	const int mValue;
	int &mReference;
};
#pragma pack()

int main()
{
	CTest test(33);
	printf("sizeof CTest is %llu\n", sizeof(test));
	return 0;
}

初始化列表顺序问题：初始化顺序按在类中声明顺序进行，否则会出现编译警告。

#include <stdio.h>
#include <stdlib.h>



class CTest
{
public:
	CTest(int val): mValue2(val), mValue1(mValue2)
	{
		printf("mValue1 = %d, mValue2 = %d\n", mValue1, mValue2);
	}
	~CTest()
	{
		
	}

private:
	int mValue1;
	int mValue2;
};

int main()
{
	CTest test(33);
	printf("sizeof CTest is %lu\n", sizeof(test));
	return 0;
}

代码意图是想用构造函数里的参数来初始化 mValue2，然后再用 mValue2 来初始化 mValue1，但实际 mValue1 初始化要先于 mValue2，所以它的值是未知的， 可能是个随机值：

 mValue2 正确赋值了，但 mValue1 并不是预想的是 mValue2 的值，所以还是老老实实地按声明顺序来吧。