对象组合通过成员变量实现“has-a”关系，如Car类包含Engine对象，实现代码复用与低耦合。
在C++的面向对象编程中，对象组合与委托是实现代码复用和职责分离的重要手段。它们比继承更灵活，能有效降低类之间的耦合度。下面介绍如何在C++中实现这两种设计方式。
对象组合：通过成员对象实现“拥有”关系
组合表示一个类包含另一个类的对象作为其成员，体现“has-a”关系。与继承不同，组合强调的是整体与部分的关系。
例如，一个Car类可以包含一个Engine对象：
class Engine {
public:
void start() {
std::cout << "Engine started.\n";
}
void stop() {
std::cout << "Engine stopped.\n";
}
};
class Car {
private:
Engine engine; // 组合：Car拥有Engine
public:
void start() {
std::cout << "Car starting...\n";
engine.start(); // 调用组合对象的方法
}
void stop() {
engine.stop();
std::cout << "Car stopped.\n";
}
};
这里Car通过组合Engine来复用其功能，而不是继承。这种设计更直观，也更容易维护。
立即学习“C++免费学习笔记（深入）”；
委托：将任务交给其他对象处理
委托是一种设计思想，指一个对象将某些职责“委托”给另一个对象执行。它通常通过组合实现，即类中持有一个指向其他对象的引用或指针。
例如，一个Printer类可以将打印任务委托给不同的PrintStrategy对象：
class PrintStrategy {
public:
virtual void print(const std::string& text) = 0;
virtual ~PrintStrategy() = default;
};
class ConsolePrint : public PrintStrategy {
public:
void print(const std::string& text) override {
std::cout << "Console: " << text << std::endl;
}
};
class FilePrint : public PrintStrategy {
public:
void print(const std::string& text) override {
std::ofstream file("output.txt", std::ios::app);
file << "File: " << text << std::endl;
file.close();
}
};
class Printer {
private:
PrintStrategy strategy; // 委托对象
public:
explicit Printer(PrintStrategy s) : strategy(s) {}
void setStrategy(PrintStrategy* s) {
strategy = s;
}
void print(const std::string& text) {
if (strategy) {
strategy->print(text); // 委托给策略对象
}
}
};
这样，Printer不关心具体如何打印，只负责调用委托对象的方法。运行时可以动态更换策略，灵活性高。
使用智能指针管理组合对象生命周期
在现代C++中，推荐使用智能指针管理组合对象，避免内存泄漏。
例如，将上面的Printer改用std::unique_ptr：
class Printer {
private:
std::unique_ptr strategy;
public:
explicit Printer(std::unique_ptr s)
: strategy(std::move(s)) {}
void setStrategy(std::unique_ptr s) {
strategy = std::move(s);
}
void print(const std::string& text) {
if (strategy) {
strategy->print(text);
}
}
};
这样可以自动管理策略对象的生命周期，代码更安全。
基本上就这些。组合与委托让C++程序更模块化，易于扩展和测试。比起继承，它们更适合表达行为复用和运行时多态。实际开发中，优先考虑组合与委托，再考虑继承。不复杂但容易忽略。
