初始化列表及const、static修饰成员

1、构造函数的初始化列表

初始化顺序和初始化列表的顺序无关，和成员变量/对象的声明顺序有关。

class Test
{
public:
	Test(int a, int b) : mb(ma), ma(a), mc(ma)
	{}
	void Show()
	{
		std::cout << "ma:" << ma << std::endl;
		std::cout << "mb:" << mb << std::endl;
		std::cout << "mc:" << mc << std::endl;
	}
private:
	int ma;
	int mb;
	int mc;
};
int main()
{
	Test test1(10,20);
	test1.Show();
	return 0;
}

运行结果为：ma =10;mb = 10;mc = 10; 

2、常对象和常方法

1. 常对象不能调用普通方法
2. 常对象只能调用常方法
3. 普通对象也可以调用常方法
4. 普通方法可以调用常方法
5. 常方法中不能调用普通方法

class Test
{
public:
	Test(int a, int b) : mb(b), ma(a)        //this Test* const
	{}
	void Show()const                            //this  const Test* const
	{
		std::cout << "ma:" << ma << std::endl;
		std::cout << "mb:" << mb << std::endl;
	}
	void Print()                                     //this Test* const
	{
		std::cout << "hello world !" << std::endl;
		//(*this).Show();
	}
private:
	int ma;
	int mb;
};

int main()
{
	Test test1(10, 20);
	test1.Show();                        //Test*  ==> Test* const
	const Test test2(30, 40);
	test2.Show();                       //const Test*  ==>  Test* const
	system("pause");
	return 0;
}

常成员变量：一定要初始化（构造函数的初始化列表中）

class Test
{
public:
	Test(int a, int b) :       
		ma(a)
	{
		mb = b;
	}
	void Show()
	{
		std::cout << "ma:" << ma << std::endl;
		std::cout << "mb:" << mb << std::endl;
	}

private:
	const int ma;         //ma必须初始化
	int mb;
};
int main()
{
	Test test1(10, 20);
	test1.Show();
	system("pause");
	return 0;
}

3、static修饰词

修饰成员变量

1. 不属于对象独享（对象共享）
2. 一定要在类外初始化
3. 不依赖对象访问

修饰成员方法

1. _cdecl，没有this指针
2. 不能访问普通成员变量
3. 可以访问静态的成员变量和全局变量
4. 静态成员方法不能调用普通的成员方法
5. 普通成员方法可以调用静态的成员方法

int gdata = 10;
class Test
{
public:
	Test(int a, int b)
	{
		mb = b;
	}
	static void Show()     //_cdecl，无this指针
	{
		std::cout << "ma:" << ma << std::endl;
		//std::cout << "mb:" << mb << std::endl;        //不能访问普通成员变量
		std::cout << "mb:" << gdata << std::endl;     //可以访问全局变量
		//Print();                                    //静态成员方法不能调用普通成员方法
	}
	void Print()             //thiscall   this Test* const this
	{
		//std::cout << "ma:" << ma << std::endl;
		//std::cout << "mb:" << this->mb << std::endl;
		Show();                             //普通成员方法可以调用静态成员方法
	}
public:
	static int ma;
	int mb;
};

int Test::ma = 10;
int main()
{
	Test test1(10, 20);
	std::cout << sizeof(Test) << std::endl;
	std::cout << test1.mb << std::endl;
	std::cout << test1.ma << std::endl;
	Test::Show();
	test1.Show();
	return 0;
}