C++初始化对象参数个数不同的对象数组

/*
1，构造函数和复制构造函数可以只对部分私有成员初始化
2，初始化对象数组，对象初始化对象所需参数个数不同，需要重载构造函数
在初始化的时候，形式不一样
Sample f[5] = { 1,2,3,4,5 };
//Sample h[5] = { (1,2),(3,4),(5,6),(7,8), (9,10)};//不报错，调用的one个参数的构造函数，这不是预期的
Sample h[5] = { Sample(1,2),Sample(3,4),Sample(5,6),Sample(7,8),Sample(9,10) };
//Sample k[5] = { (1,2,3),(3,4,5),(5,6,7),(7,8,9),(9,10,11) }; //不报错，调用的one个参数的构造函数，这不是预期的,传的是靠右括号的那个参数
Sample k[5] = { Sample(1,2,3),Sample(3,4,5),Sample(5,6,7),Sample(7,8,9),Sample(9,10,11) };
3， Sample d;//调用默认构造函数
d = a;//d已经是对象，这样初始化不调用复制构造函数
*/

#include<iostream>
using namespace std;
class Sample
{
private:
	int v, w,z=100;
public:
	Sample() { cout << "默认构造函数" << endl; }
	Sample(int n) :v(n) { cout << "含one个参构造函数" << endl; }//可以对其中一个私有成员初始化，没被初始化的成员随机得到一个值
	Sample(int n,int m) :v(n) ,w(m){ cout << "含two个参构造函数" << endl; }
	Sample(int n, int m,int z1) :v(n), w(m),z(z1) { cout << "含three个参构造函数" << endl; }
	Sample(const Sample &x) {
		v =  x.v;
		w= x.w;
		z = x.z;
		cout << "复制构造函数" << endl;
	}
	int  getv(Sample p)
	{
		return p.v;
	}
	int  getw(Sample p)
	{
		return p.w;
	}
	int  getz(Sample p)
	{
		return p.z;
	}
};

int main()
{
	Sample a(5);//含one个参构造函数,w=随机，z=采用初始化值z=100
	Sample b = a;//调用复制构造函数—>用对象初始化赋值
	cout << "b。。。。。" << endl;
	cout << b.getv(b)<<','<<b.getw(b)<<',' << b.getz(b) << endl;//调用3次复制构造函数—>对象实形结合
	cout << "b。。。。。" << endl;

	Sample d;//调用默认构造函数
	d = a;//d已经是对象，这样初始化不调用复制构造函数
	cout << "d。。。。。" << endl;
	cout << d.getv(d) << ',' << d.getw(d) << ',' << d.getz(d) << endl;//调用3次复制构造函数—>对象实形结合
	cout << "d。。。。。" << endl;


	Sample e(10,12);//含two个参构造函数,还有一个参数z采用初始化值z=100
	b = e;//已经是对象的，再用对象初始化不调用构造函数
	cout << "be。。。。。" << endl;
	cout << b.getv(b) << ',' << b.getw(b) << ',' << b.getz(b) << endl;//调用3次复制构造函数—>对象实形结合
	cout << e.getv(e) << ',' << e.getw(e) << ',' << e.getz(e) << endl;//调用3次复制构造函数—>对象实形结合
	cout << "be。。。。。" << endl;
	Sample g(10, 12,13);//含three个参构造函数传了参，采用传过来的，z=13
	cout << "g。。。。。" << endl;
	cout << g.getv(g) << ',' << g.getw(g) << ',' << g.getz(g) << endl;//调用3次复制构造函数—>对象实形结合
	cout << "g。。。。。" << endl;


	cout << "用初始化列表初始化带1个参数的对象数组" << endl;
	Sample f[5] = { 1,2,3,4,5 };
	cout << " f.如下" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << f[i].getv(f[i]) << ','<<f[i].getw(f[i]) << ',' << f[i].getz(f[i]) << endl;
	}


	cout << "用初始化列表初始化带2个参数的对象数组" << endl;
	//Sample h[5] = { (1,2),(3,4),(5,6),(7,8), (9,10)};//不报错，调用的one个参数的构造函数，这不是预期的
	Sample h[5] = { Sample(1,2),Sample(3,4),Sample(5,6),Sample(7,8),Sample(9,10) };
	cout << " h.如下" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << h[i].getv(h[i]) << ',' << h[i].getw(h[i]) << ',' << h[i].getz(h[i]) << endl;
	}
	
	cout << "用初始化列表初始化带3个参数的对象数组" << endl;
	//Sample k[5] = { (1,2,3),(3,4,5),(5,6,7),(7,8,9),(9,10,11) }; //不报错，调用的one个参数的构造函数，这不是预期的,传的是靠右括号的那个参数
	Sample k[5] = { Sample(1,2,3),Sample(3,4,5),Sample(5,6,7),Sample(7,8,9),Sample(9,10,11) };
	cout << " k.如下" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << k[i].getv(k[i]) << ',' << k[i].getw(k[i]) << ',' << k[i].getz(k[i]) << endl;
	}
}

运行结果：

含one个参构造函数
复制构造函数
b。。。。。
复制构造函数
复制构造函数
复制构造函数
5,-858993460,100
b。。。。。
默认构造函数
d。。。。。
复制构造函数
复制构造函数
复制构造函数
5,-858993460,100
d。。。。。
含two个参构造函数
be。。。。。
复制构造函数
复制构造函数
复制构造函数
10,12,100
复制构造函数
复制构造函数
复制构造函数
10,12,100
be。。。。。
含three个参构造函数
g。。。。。
复制构造函数
复制构造函数
复制构造函数
10,12,13
g。。。。。
用初始化列表初始化带1个参数的对象数组
含one个参构造函数
含one个参构造函数
含one个参构造函数
含one个参构造函数
含one个参构造函数
 f.如下
复制构造函数
复制构造函数
复制构造函数
1,-858993460,100
复制构造函数
复制构造函数
复制构造函数
2,-858993460,100
复制构造函数
复制构造函数
复制构造函数
3,-858993460,100
复制构造函数
复制构造函数
复制构造函数
4,-858993460,100
复制构造函数
复制构造函数
复制构造函数
5,-858993460,100
用初始化列表初始化带2个参数的对象数组
含two个参构造函数
含two个参构造函数
含two个参构造函数
含two个参构造函数
含two个参构造函数
 h.如下
复制构造函数
复制构造函数
复制构造函数
1,2,100
复制构造函数
复制构造函数
复制构造函数
3,4,100
复制构造函数
复制构造函数
复制构造函数
5,6,100
复制构造函数
复制构造函数
复制构造函数
7,8,100
复制构造函数
复制构造函数
复制构造函数
9,10,100
用初始化列表初始化带3个参数的对象数组
含three个参构造函数
含three个参构造函数
含three个参构造函数
含three个参构造函数
含three个参构造函数
 k.如下
复制构造函数
复制构造函数
复制构造函数
1,2,3
复制构造函数
复制构造函数
复制构造函数
3,4,5
复制构造函数
复制构造函数
复制构造函数
5,6,7
复制构造函数
复制构造函数
复制构造函数
7,8,9
复制构造函数
复制构造函数
复制构造函数
9,10,11
请按任意键继续. . .