【C++】mooc_9 成员对象和封闭类

1 封闭类和成员对象

封闭类：有成员对象的类
成员对象：一个类的成员是其他类的对象

#include 
using namespace std;
//封闭类：有成员对象的类
class Tyre{
    private:
        int radius;
        int width;
    public:
        Tyre(int r, int w){
            radius = r;
            width = w;
        }
};

class Engine{};
class Car{    //封闭类
    private:
        int price;
        Tyre tyre;       //成员对象
        Engine engine;   //成员对象
    public:
        Car(int p, int tr, int tw);
};
Car::Car(int p, int tr, int tw):price(p), tyre(tr,tw)
{
};

int main(){
    Car car(200, 17, 5);
    return 0;
}

若car不写构造函数，编译器在自动调用默认构造函数的时候会报错，因为不知道tyre怎么初始化。engine没问题

2 封闭类构造函数析构函数的执行顺序

1. 执行所有对象成员的构造函数
2. 执行封闭类的构造函数
3. 对象成员的构造函数调用次序与其在封闭类中的说明顺序一致，与初始化列表中顺序无关
4. 封闭类的对象消亡时，先执行封闭类析构函数
5. 执行成员对象的析构函数

#include 
using namespace std;
//封闭类：有成员对象的类
class Tyre{
    public:
        Tyre(){cout << "tyre constructor"<<endl;}
        ~Tyre(){cout << "tyre destructor"<<endl;}
};

class Engine{
    public:
        Engine(){ cout << "engine constructor"<<endl; }
        ~Engine(){ cout << "engine destructor"<<endl; }
};
class Car{    //封闭类
    private:
        Tyre tyre;       //成员对象
        Engine engine;   //成员对象
    public:
  
        Car(){cout << "car constructor"<<endl; price = 1;}
        ~Car(){cout << "car destructor"<<endl;}
};

int main(){
    //Car car(200, 17, 5);
    Car car;
    return 0;
}

输出：

tyre constructor
engine constructor
car constructor
car destructor
engine destructor
tyre destructor

3 封闭类的复制构造函数

class A{
    public:
        A(){cout << "default" << endl;}
        A(A & a){cout << "copy" <<endl;}
};

class B{
    A a;
};

int main(){
    B b1, b2(b1);
    return 0;
}

输出：
defalut
copy

即用A的复制构造函数初始化b2.a，且复制构造函数的实参是b1.a