c++类的组合

类的组合描述的是一个类内嵌其他类的对象作为成员的情况，它们之间的关系是一种包含与被包含的关系

class Engine {  
public:  
    void start() {  
        // 启动引擎的逻辑  
        std::cout << "Engine started!" << std::endl;  
    }  
  
    // ... 其他引擎相关的方法 ...  
};  
  
class Car {  
private:  
    Engine engine; // Car类包含一个Engine类的对象作为成员  
  
public:  
    void startCar() {  
        engine.start(); // 调用Engine对象的start方法  
        // ... 其他启动汽车的逻辑 ...  
    }  
  
    // ... 其他汽车相关的方法 ...  
};  
  
int main() {  
    Car myCar;  
    myCar.startCar(); // 输出：Engine started! ...（其他启动汽车的逻辑）  
    return 0;  
}

注意：

若创建类的对象时，此类中具有内嵌对象成员，那么各个内嵌对象将被自动创建

在创建对象是要对内嵌对象成员进行初始化

class Inner {  
public:  
    int value;  
    Inner(int v) : value(v) {} // Inner类的构造函数  
};  
 
class Outer {  
public:  
    Inner innerObj;  
    Outer(int v) : innerObj(v) {} // 使用初始化列表初始化innerObj  
};  
 
int main() {  
    Outer outer(10); // 创建一个Outer对象，并使用10来初始化其innerObj成员  
    // 此时outer的innerObj的value成员已经被初始化为10  
}

聚合初始化（C++11及以后版本）：
对于聚合类型（没有用户定义的构造函数、没有私有或保护的非静态数据成员、没有基类也没有虚函数的类），可以使用聚合初始化来初始化成员。

#include<iostream>  
using namespace std;  
  
class Inner {  
public:  
   int value;
   
};  
 
class Outer {  
public:  
    Inner innerObj; 
	void coutt()
   {
   	cout<<innerObj.value; 
	 }   
};  
int main() {  
    Outer outer = {Inner{10}}; // 使用聚合初始化来初始化outer的innerObj成员  
    // 此时outer的innerObj的value成员已经被初始化为10 
	outer.coutt();
}

组合类构造函数的定义一般形式：

类名：：类名（形参表）：内嵌对象1（形参表），内嵌对象2（形参表）{

类的初始化

}

对基本数据成员也可以定义为

A：：A（int a）：r(a){}       r基本数据成员

调用内嵌构造函数顺序：按内嵌对象定义的顺序调用

注意：在构造函数中出现的顺序和调用顺序无关

#include <iostream>  
  
class Inner1 {  
public:  
    Inner1() { std::cout << "Inner1 constructor\n"; }  
};  
  
class Inner2 {  
public:  
    Inner2() { std::cout << "Inner2 constructor\n"; }  
};  
  
class Outer {  
public:  
    Inner1 inner1;  
    Inner2 inner2;  
  
    Outer() : inner2(), inner1() { // 初始化列表中的顺序与构造函数的调用顺序无关  
        // 注意：即使这里inner2在inner1之前，但inner1的构造函数仍然会先被调用  
    }  
};  
  
int main() {  
    Outer outer; // 构造Outer对象  
    return 0;  
}

输出结果

Inner1 constructor

Inner2 constructor

若有些对象为出现在构造函数中，也会被调用：

#include <iostream>  
  
class Inner1 {  
public:  
    Inner1() { std::cout << "Inner1 constructor\n"; }  
};  
  
class Inner2 {  
public:  
    Inner2() { std::cout << "Inner2 constructor\n"; }  
};  
  
class Outer {  
public:  
    Inner1 inner1;  
    Inner2 inner2;  
  
    Outer() {  
        // 注意：没有在初始化列表中明确列出inner1和inner2  
        // 但它们的构造函数仍然会按照声明顺序被调用  
    }  
};  
  
int main() {  
    Outer outer; // 构造Outer对象  
    return 0;  
}

输出结果

Inner1 constructor

Inner2 constructor

 

#include <iostream>  
  
class Inner {  
public:  
    Inner() { std::cout << "Inner constructor\n"; }  
    ~Inner() { std::cout << "Inner destructor\n"; }  
};  
  
class Outer : public Base { // 假设有一个基类Base  
public:  
    Inner inner1;  
    Inner inner2;  
  
    Outer() {  
        std::cout << "Outer constructor\n";  
    }  
  
    ~Outer() {  
        std::cout << "Outer destructor\n";  
    }  
};  
  
class Base {  
public:  
    Base() { std::cout << "Base constructor\n"; }  
    ~Base() { std::cout << "Base destructor\n"; }  
};  
  
int main() {  
    Outer outer;  
    return 0;  
}

Base constructor // 基类构造函数

Inner constructor // 成员inner1的构造函数

Inner constructor // 成员inner2的构造函数

Outer constructor // 当前类Outer的构造函数

Outer destructor // 当前类Outer的析构函数

Inner destructor // 成员inner2的析构函数（逆序）

Inner destructor // 成员inner1的析构函数（逆序）

Base destructor // 基类析构函数

组合类的复制构造函数

 Outer(const Outer& other) : inner1(other.inner1), inner2(other.inner2){}

#include <iostream>  
  
class Inner {  
public:  
    int value;  
      
    Inner(int v = 0) : value(v) {  
        std::cout << "Inner constructor with value " << value << std::endl;  
    }  
      
    Inner(const Inner& other) : value(other.value) {  
        std::cout << "Inner copy constructor with value " << value << std::endl;  
    }  
      
    // ... 其他成员函数 ...  
};  
  
class Outer {  
public:  
    Inner inner1;  
    Inner inner2;  
      
    Outer(int v1 = 0, int v2 = 0) : inner1(v1), inner2(v2) {  
        std::cout << "Outer constructor" << std::endl;  
    }  
      
    // 复制构造函数  
    Outer(const Outer& other) : inner1(other.inner1), inner2(other.inner2) {  
        std::cout << "Outer copy constructor" << std::endl;  
    }  
      
    // ... 其他成员函数 ...  
};  
  
int main() {  
    Outer original(1, 2); // 调用Outer和Inner的构造函数  
    Outer copy = original; // 调用Outer的复制构造函数，它会调用Inner的复制构造函数  
    return 0;  
}

Inner constructor with value 1  
Inner constructor with value 2  
Outer constructor  
Outer copy constructor  
Inner copy constructor with value 1  
Inner copy constructor with value 2