第三天之多个对象构造和析构

1、对象初始化列表

1）对象初始化列表出现原因
1.必须这样做：
如果我们有一个类成员，它本身是一个类或者是一个结构，而且这个成员它只有一个带参数的构造函数，没有默认构造函数。这时要对这个类成员进行初始化，就必须调用这个类成员的带参数的构造函数，
如果没有初始化列表，那么他将无法完成第一步，就会报错。

2、类成员中若有const修饰，必须在对象初始化的时候，给const int m 赋值
当类成员中含有一个const对象时，或者是一个引用时，他们也必须要通过成员初始化列表进行初始化，
因为这两种对象要在声明后马上初始化，而在构造函数中，做的是对他们的赋值，这样是不被允许的。
2）C++中提供初始化列表对成员变量进行初始化
语法规则
Constructor::Contructor() : m1(v1), m2(v1,v2), m3(v3)
{
// some other assignment operation
}
3）注意概念
初始化：被初始化的对象正在创建
赋值：被赋值的对象已经存在

4）注意：
成员变量的初始化顺序与声明的顺序相关，与在初始化列表中的顺序无关
初始化列表先于构造函数的函数体执行

#define _CRT_SECURE_NO_WARNINGS
#include "iostream"
using namespace std;class A
{
public:A(int _a){a = _a;cout << "构造函数" << "a" << a << endl;}~A(){cout << "析构函数" << "a" << a << endl;}
private:int a;
};//一、构造函数的初始化列表  解决 在B类中，组合了一个A类对象（A类设计了构造函数）
//根据构造函数的调用规则写了A类的构造函数必须要用，用B定义对象时没有机会初始化A
//新的语法：Constructor::Contructor() : m1(v1), m2(v1, v2),m3(v3)
class B
{
public:B(int _b1, int _b2) : a1(1), a2(2), c(0){}B(int _b1, int _b2, int m, int n) : a1(m), a2(n), c(0){b1 = _b1;b2 = _b2;}~B(){cout << "B的析构函数" << endl;}
private:int b1;int b2;A a1;A a2;const int c;    //如果有const变量，在参数列表中初始化
};//二、执行顺序：
//先执行被组合对象的构造函数
//如果组合对象有多个，按照定义顺序而不是按照初始化列表的顺序//析构函数 和构造函数的调用顺序相反//三、被组合对象B的顺序与定义顺序有关系，与初始化列表的顺序没有关系
void obj10play()
{//A a1(10);//B objB(1, 2);//1、参数传递B objB2(1, 2, 3, 4);//2、调用顺序return;
}void main()
{obj10play();cout << "hello" << endl;system("pause");
}

2、强化训练

#include <iostream>
using namespace std;class   ABCD
{
public:ABCD(int a, int  b, int  c){_a = a;_b = b;_c = c;printf("ABCD()  construct,  a:%d,b:%d,c:%d      \n", _a, _b, _c);}~ABCD(){printf("~ABCD() construct,a:%d,b:%d,c:%d        \n", _a, _b, _c);}int  getA(){return   _a;}private:int _a;int  _b;int  _c;
};class MyE
{
public:MyE() :abcd1(1, 2, 3), abcd2(4, 5, 6), m(100){cout << "MyE()" << endl;}MyE(const   MyE &   obj) :abcd1(7, 8, 9), abcd2(10, 11, 12), m(100){printf("MyE(const MyE()    &   obj)\n");}~MyE(){cout << "~MyE()" << endl;}
public:ABCD abcd1;  //c++编译器不知道如何构造abc1ABCD   abcd2;const int m;
};int   doThing(MyE mye1) //mye1 = myE //mye1.拷贝构造函数(myE)
{printf("doThing() mye1.abc1.a:%d \n", mye1.abcd1.getA());return 0;
}int    run()
{MyE    myE; //调用的无参构造函数doThing(myE);return 0;
}int    run2()
{printf("run2  start..\n");//直接调用构造函数将会产生匿名对象ABCD(400, 500, 600); //临时对象的⽣命周期只存在于这句话    //会产生一个临时的匿名对象。//再次析构匿名对象                                                     //匿名的临时对象，编译器会立刻销毁。不等到正常函数调用完毕。，ABCD  abcd = ABCD(100, 200, 300);printf("run2   end\n");//在此析构abcdreturn 0;
}int    main(void)
{run();//run2();return 0;
}

匿名对象的生命周期

直接调用构造函数将会产生匿名对象

int  main(void)
{//run();run2();return 0;
}

在构造函数中调用构造函数（产生匿名对象）

在构造函数中调用构造函数是一种危险的行为

#include <iostream>
using namespace std;
//构造中调⽤构造是危险的⾏为class    MyTest
{
public:MyTest(int   a, int  b, int  c) //有参 构造函数{_a = a;_b = b;_c = c;}MyTest(int    a, int  b) //有参数的构造函数，两个参数{_a = a;_b = b;//构造函数中，无法嵌套构造函数 来通过构造函数给自己的成员变量赋值，//此构造函数已经又创建了另一个对象。MyTest(a, b, 100);    //产⽣新的匿名对象//新的匿名对象 a->1 b->2 c ->100}~MyTest(){printf("MyTest~:%d,    %d, %d\n", _a, _b, _c);}int    getC(){return   _c;}void    setC(int    val){_c = val;}private:int _a;int  _b;int  _c;
};int   main()
{MyTest t1(1, 2); //t1.a -->1  t1.b -->2 t1.c--->? printf("c:%d\n", t1.getC());  //请问c的值是？return 0;
}