C++组合类举例

一个C++组合类的例子如下：

class Engine {
public:
    void start() {
        // 启动引擎
    }
};

class Car {
private:
    Engine engine;

public:
    void start() {
        engine.start(); // 调用Engine类的start方法
        // 启动汽车
    }
};

在这个例子中，Car类包含一个Engine类的对象，称为组合。Car类的start方法内部调用了Engine类的start方法，实现了汽车启动时启动引擎的功能。

相关问题

详细描述 依赖、组合、聚合、关联 并用C++举例

在面向对象设计中，四种常见关系包括：

1. **依赖** (Dependency)：当一个类A需要另一个类B的功能才能正常工作时，我们说A依赖于B。例如，在C++中，类A有一个指向类B的对象引用，但没有包含它。如果B改变，A不需要修改，只是在使用B功能的地方可能会受到影响。例如：

   class B {
   public:
       void doSomething();
   };
   
   class A {
   private:
       B* b;
   public:
       void useB() { b->doSomething(); }
   };

2. **组合** (Composition): 类A包含一个或多个属于类B的对象实例，表示A是由B的实例构成的。例如，一个"汽车"类可以组合多个"轮胎"对象：

   class Car {
   private:
       std::vector<Tire> tires;
   public:
       void addTire(Tire tire) { tires.push_back(tire); }
   };

如果"轮胎"改变，那么所有"汽车"实例都会受影响。

3. **聚合** (Aggregation): 类似于组合，但聚合允许部分独立存在，即没有主从关系。比如，一个"图书馆"可以聚合多个"书籍"，但一本书并不一定要属于某个特定的图书馆。在C++中，可以使用指针或智能指针：

   class Book;
   
   class Library {
   private:
       std::list<Book*> books;
   public:
       void addBook(Book* book);
   };

4. **关联** (Association): 它是最弱的关系，简单地说就是两个类之间有某种连接，但它们不是整体包含部分或者部分组成整体。例如，学生和课程之间的关系，每个学生可以选择一门或多门课程：

   class Student;
   class Course {
   public:
       std::vector<Student*> students;
   };
   
   class Student {
   private:
       Course* course; // 可能为空
   public:
       void enrollIn(Course& course);
   };

C++模板类型有两种，举例说明

C++中的模板类型有全特化（full specialization）和一般特化（partial specialization）。这里以类模板为例[^1]：

1. **全特化**（Template Specialization）: 当特定类型的组合完全匹配模板参数时，会创建一个新的独立模板实例。如类`Data`的全特化：

   // 对于Data类模板，如果只特化T1为int，T2为double
   template<> class Data<int, double> {
       public: 
           Data() { cout << "Data<int, double>" << endl; }
           private: 
               int _a1;
               double _a2;
   };

2. **一般特化（Partial Specialization）**: 如果只对部分模板参数进行特化，其余参数保持通用。如`swap`函数模板的部分特化：

   // 只特化交换两个特定类型的变量
   template<> void swap(int &a, int &b) { ... } // 特化为int类型
   template<> void swap(double &a, double &b) { ... } // 特化为double类型

这两种特化允许程序员针对特定情况定制模板行为，提高代码效率和针对性。