类和结构初始化的写法及不同

//总结：
//C++中类与结构初始化的方式基本一致，如下：
//1.分为列表初始化和构造函数函数初始化（列表初始化在一定程度上与构造函数有关联）
//2.列表和构造函数初始化按照写法的不同还可以再分，见代码
//不同的地方有如下几个：
//1.类列表初始化只有当所有成员都为公有或有匹配的构造函数时才可以用（结构就是所有成员都是公有的类）
//2.这点仅限于VS，即若结构没有显式初始化则VS不会通过，类显隐式都可以

#include<iostream>

using namespace std;

struct SA
{
	int x;
	float y;
};

struct SB
{
	int x;
	float y;

	SB()
	{
		x = -1;
		y = -2;
	}
};

struct SC
{
	int x;
	float y;

	SC()
	{
		x = -1;
		y = -2;
	}

	SC(int _x, float _y)
	{
		x = _x;
		y = _y;
	}
};

struct SD
{
	int x;
	float y;

	SD(int _x, float _y)
	{
		x = _x;
		y = _y;
	}
};

class CA
{
public:
	void show()
	{
		cout << x << endl;
	}
private:
	int x;
	float y;
};

class CB
{
public:
	CB()
	{
		x = -1;
		y = -2;
	}
	void show()
	{
		cout << x << endl;
	}
private:
	int x;
	float y;
};

class CC
{
public:
	CC()
	{
		x = -1;
		y = -2;
	}
	CC(int _x, float _y)
	{
		x = _x;
		y = _y;
	}
	void show()
	{
		cout << x << endl;
	}
private:
	int x;
	float y;
};

class CD
{
public:
	CD(int _x, float _y)
	{
		x = _x;
		y = _y;
	}
	void show()
	{
		cout << x << endl;
	}
private:
	int x;
	float y;
};

int main()
{
	SA sa1 = { 1, 2.3 };
	SA sa2 = { 1 };
	SA sa3{ 1,2.3 };
	SA sa4{}; //调用无参构造函数
	SA sa5 = SA(); //调用无参构造函数
	//SA sa6(); //与函数冲突，不允许，应去掉括号
	//SA sa7; //VS中不通过，但C++规定中此时会执行默认的构造函数

	//重新自定义无参构造函数后
	//SB sb1 = {1,2.3}; //失去列表初始化特性
	//SB sb2 = {1}; //失去列表初始化特性
	//SB sb3{ 1,2.3 }; //失去列表初始化特性
	SB sb4{}; //调用无参构造函数
	SB sb5 = SB(); //调用无参构造函数
	//SB sb6(); //与函数冲突，不允许，应去掉括号
	//SB sb7; //VS中不通过，但C++规定中此时会执行默认的构造函数

	//重新自定义无参和有参构造函数后
	SC sc1 = { 1,2.3 };
	//SC sc2{ 1 }; //不允许
	SC sc3{};//调用无参构造函数
	SC sc4 = SC();
	//SC sc5(); //与函数冲突，不允许，应去掉括号
	//SC sc6; //VS中不通过，但C++规定中此时会执行默认的构造函数
	SC sc7 = SC(1, 2.3);
	SC sc8(1, 2.3);

	//重新有参构造函数而不定义无参构造函数后
	SD sd1 = { 1,2.3 };
	//SD sd2{ 1 }; //不允许
	//SD sd3{};//不允许
	//SD sd4 = SD();//不允许
	//SD sd5(); //与函数冲突，不允许，应去掉括号
	//SD sd6; //不通过
	SD sd7 = SD(1, 2.3);
	SD sd8(1, 2.3);

	//CA ca1 = { 1,2.3 }; //私有成员不能用列表初始化，只有公有才可以，且所有成员都为公有
	//CA ca2 = { 1 }; //私有成员不能用列表初始化，只有公有才可以，且所有成员都为公有
	//CA ca3{ 1,2.3 }; //私有成员不能用列表初始化，只有公有才可以，且所有成员都为公有
	CA ca4{};
	CA ca5 = CA();
	//CA ca6(); //与函数冲突，不允许，应去掉括号
	CA ca7; //与结构不同，VS通过，C++规定执行默认构造函数

	//重新自定义无参构造函数后
	//CB cb1 = { 1,2,3 }; //私有成员不能用列表初始化，只有公有才可以，且所有成员都为公有
	//CB cb2 = { 1 }; //私有成员不能用列表初始化，只有公有才可以，且所有成员都为公有
	//CB cb3{ 1,2,3 }; //私有成员不能用列表初始化，只有公有才可以，且所有成员都为公有
	CB cb4{}; //调用无参构造函数
	CB cb5 = CB(); //调用无参构造函数
	//CB cb6(); //与函数冲突，不允许，应去掉括号
	CB cb7; //与结构不同，VS通过，C++规定执行默认构造函数
	
	//重新自定义无参和有参构造函数后
	CC cc1 = { 1,2.3 };
	//CC cc2{ 1 }; //不允许
	CC cc3{};//调用无参构造函数
	CC cc4 = CC();
	//CC cc5(); //与函数冲突，不允许，应去掉括号
	CC cc6; //与结构不同，VS通过，C++规定中此时会执行默认的构造函数
	CC cc7 = CC(1, 2.3);
	CC cc8(1, 2.3);
	
	//重新有参构造函数而不定义无参构造函数后
	CD cd1 = { 1,2.3 };
	//CD cd2{ 1 }; //不允许
	//CD cd3{};//不允许
	//CD cd4 = CD();//不允许
	//CD cd5(); //与函数冲突，不允许，应去掉括号
	//CD cd6; //不允许
	CD sd7 = CD(1, 2.3);
	CD sd8(1, 2.3);
}