组合和聚合
不是c++的语法要求，是一种建模思想
目录
1.组合
1. 使用 -- 在一个类中创建另外一个类的对象
代码中的解释:
代码结果：
组合：
2. 使用 -- 在一个类中创建另外一个类的指针
2.使用类定义一个指针 -- 不是创建一个对象
3.聚合
1. 使用
代码中的解释：
结果：
聚合：
1.组合
1. 使用 -- 在一个类中创建另外一个类的对象
就是,一个类中包含有另外一个类创建的对象。(则这两个类就是组合关系)
根据下面代码说明组合的关系。
// 实现创建两个类，使用类文件分离的方式
testCPU.h:
class testCPU
{
public:
// 使用指针传入字符串
testCPU(const char *versionCpu = "intel");
void setCpu(const char* versionCpu);
~testCPU();
private:
string versionCpu; // CPU的类型
};
testComputer.h:
#include "testCPU.h" // 导入Ccpu头文件使用其构造函数
class testComputer
{
public:
// 使用指针传字符串更加的高效，并且可以直接复制给string类型
testComputer(const char *version="len",int memory = 64,const char*
versionCpu = "intel");
~testComputer();
private:
int memory; // 电脑的内存大小
testCPU cpu; // 在testComputer内部创建testCPU类对象
};
testComputer.cpp:
testComputer::testComputer(const char* version, int memory, const char*
versionCpu ){
this->cpu.setCpu(versionCpu);
cout << __FUNCTION__ << endl; // 打印调用函数的名字
}
testComputer::~testComputer() {
cout << __FUNCTION__ << endl;
}
testCPU.cpp:
testCPU::testCPU(const char* versionCpu){
cout << __FUNCTION__ << endl; // 打印函数的名字
}
void testCPU::setCpu(const char* versionCpu) {
this->versionCpu = versionCpu;
}
testCPU::~testCPU(){
cout << __FUNCTION__ << endl; // 打印函数的名字
}
main.cpp:
void test() {
testComputer com; //使用测试函数,测试组合的规则
}
int main(void){
test();
system("pause");
return 0;
}
代码中的解释:
1. 当我们使用string定义字符串时，在传递参数的时候，可以使用char* 来传递一个字符串的地址，然后赋值给string类型的变量。 (更加高效)
2. 我们在Computer类中创建了一个CPU类对象。
3. 在使用有参构造函数的时候，我们使用了默认值，通过指定一个默认值，保证我们在不传递数据的情况下也可以有一个值。 (在使用默认值的情况下,我们可以不传递参数的情况下调用有参构造函数。如上面，testCpu cpu 没有使用参数，但是调用的是有参构造函数，因为我们指定了默认值--但是，有默认构造函数的时候就不能这样写了，会出错)
4. 在构造函数和析构函数中，使用__FUNCTION__宏来输出调用的函数名，用来观察组合的关系。
代码结果：
组合：
在一个类中创建另外一个类的对象 ，然后这两个类会同生共死，当包含的类创建对象时，会先创建被包含类的对象，当包含类对象死亡时，被包含的类的对象也死亡 。
就相当于，你买了一台电脑，电脑里面的cpu也一起被你买到，当你不使用这台电脑的时候，里面的cpu你也不用了。
2. 使用 -- 在一个类中创建另外一个类的指针
这种情况， 就是在类中不创建对象，定义一个指向该类的指针。testCPU *cpu。因为定义的是指针，不会调用构造函数，所以要想实现组合。就得在构造函数中，为指针开辟空间。在析构函数中释放指针的空间。
3. 初始化组合的对象
建议使用初始化列表对组合成员进行初始化。
2.使用类定义一个指针 -- 不是创建一个对象
首先，使用类定义一个指针的时候是不会调用构造函数的。因为：它只是定义了一个指针，这个指针指向这个类型，并不表示创建了一个对象。 -- 其实指针是一个整形变量。
这就是为什么我们上面使用在类中定义另外一个类的指针的时候，需要自己在函数中实现开辟空间和释放空间。
3.聚合
1. 使用
// 实现创建两个类，使用类文件分离的方式
testCPU.h:
class testCPU
{
public:
// 使用指针传入字符串
testCPU(const char *versionCpu = "intel");
void setCpu(const char* versionCpu);
~testCPU();
private:
string versionCpu; // CPU的类型
};
testComputer.h:
class testCPU; // 不导入头文件，告诉编译器要使用这个类就行，（因为没有使用类中的内容,只用了类名）
class testComputer
{
public:
testComputer(testCPU *cpu); // 有参数的构造函数，传入指向对应类型的指针
void setCpu(testCPU* cpu);
~testComputer();
private:
testCPU *cpu; // 定义一个指向类的指针，并不创建对象
};
testComputer.cpp:
testComputer::testComputer(testCPU* cpu){
this->cpu = cpu;
cout << __FUNCTION__ << endl;
}
testComputer::~testComputer() {
cout << __FUNCTION__ << endl;
}
void testComputer::setCpu(testCPU* cpu) {
this->cpu = cpu;
}
testCPU.cpp:
testCPU::testCPU(const char* versionCpu){
cout << __FUNCTION__ << endl; // 打印函数的名字
}
void testCPU::setCpu(const char* versionCpu) {
this->versionCpu = versionCpu;
}
testCPU::~testCPU(){
cout << __FUNCTION__ << endl; // 打印函数的名字
}
main.cpp:
#include "testComputer.h"
#include "testCPU.h" // 因为testComputer中不包含此头文件,所以需要再此处包含头文件
using namespace std;
void test(testCPU* cpu) {
testComputer com(cpu); //使用测试函数,测试组合的规则
}
int main(void){
testCPU cpu; // 创建一个cpu的对象
test(&cpu);
system("pause");
return 0;
}
代码中的解释：
1. 聚合的代码和组合的代码CPU那块是一样的，因为他值需要定义一个类。
2. 我们在Computer类中定义了一个CPU类的指针，只使用到了CPU这个类的名称，并没有使用类中的内容，所以我们不需要包含它的头文件，只需要写一个类的声明就行。(更高效--但是需要使用类中内容的时候，就必须得包含了，比如使用构造函数创建对象) 。
3. 和组合不一样，聚合我们需要在主程序创建CPU类对象，所以需要包含其头文件。
4. 我们定义了一个指向CPU类对象的指针，通过构造函数传入，就可以使用这个指针指向传进来的对象。
结果：
根据结果：看出，当Computer创建的时候，并不会创建CPU，在Computer死亡的时候，也CPU不会死亡。-- 也就是他两的生存和死亡没有关系。
就好比：你买了一个电脑，但是里面没有CPU，但是有一个可以安装CPU的接口，你又另外买了一个CPU，安装在电脑上。当你的电脑不使用了，你的cpu还可以继续使用，你可以将它拆下来安装到别的电脑上继续使用。
聚合：
聚合其实就是,在一个类里面定义一个别的类的指针，然后在需要的时候(可以是初始化的时候，也可以不初始化，在后面使用接口(代码中的setCPU函数)再指向)，将这个类内部的指针，指向另外一个类的对象。
所以，聚合就是，类内部有一个指针，用于指向其它类的对象。当我们需要的时候将这个指针，指向这个对象就行。