当前位置：首页 > news >正文

精读C++20设计模式——结构型设计模式：组合模式

news 2025/9/30 7:25:55

精读C++20设计模式——结构型设计模式：组合模式

组合模式不是说的将对象组合起来构成一个新对象——他不是这个意思！但是实际上，他也确实是这个意思：我这么说很奇怪。因为组合模式不打算将成员们物理组合，而是逻辑组合。举个例子：我们想要为不同对象的相似逻辑提供同一接口。组合模式就是在这个时候发挥它的功能的。

我认为作者也是觉得这样的表达实在是太拗口和晦涩。这里我们跟随作者一起来动手把实验搞定。

先说说什么是组合模式吧！

组合模式（Composite）在 GoF《设计模式》中被归类为结构型设计模式。它的核心思想是：将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。

换句话说：组合模式并不是“物理组合”成员，而是通过逻辑组合来提供统一接口。它让调用者不必关心对象是单个元素还是一簇元素。在 C++20 中，我们既可以利用 std::array、std::vector 等容器简化属性组合，也可以通过虚函数、智能指针来优雅实现对象树结构。

简化属性访问——组合同一类对象为数组

现在，我们打算做一个游戏。还是挺复杂的——

class Creature
{int strength, agility, intelligence;
public:int get_strength() const { return strength; }void set_strength(const int _strength) { strength = _strength; }// 然后后面咱们省略一大堆接口，太繁琐了
};

写的时候你就发现了，实在是太抽象了。Getter Setter一大堆，但是麻烦的事情没有结束。假设我们现在准备分析Creature的自身特性——比如说我们来看看这些能力的平均分配，最出色的是哪个能力的时候——我们必须要发现，我们不得不手动处理：

int sum() const {return strength + agility + intelligence;
}double simple_avg() const { return sum() / 3.0; }int max() const {return ::max(::max(strength, agility), intelligence); }

妈耶！要是后面扩展我们的属性的时候，我相信你会抓狂的！

我们仔细看看这种情况——我们注意到，strength，agility和intelligence本身就是一种能力，不是吗？至少在这个场景。所以，我们完全可以做一个分析仪：

// 原书在这里将他们耦合进了Creature中，笔者不太赞同，毕竟——分析Creature的能力不属于Creature自身的诉求class CreatureAnalyzer
{
public:  enum Abilities { strength, agility, intelligence}// 我不赞成将表达最大的Abilities个数放到Abilities的枚举中，这是一种误用// 现代C++中已经支持了更好的constexpr，咱们用这个static constexpr const size_t ABILITIES_MAX = static_cast<int>(intelligence) + 1;CreatureAnalyzer(const Creature& analyzee){ ... }...private:std::array<int, ABILITIES_MAX>  abilities_containers;  
};

太棒了，现在，我们就把这些零散的对象在分析领域上组合成了一个属性集合。以至于我们马上就能用上标准库的代码了：

int sum() const {return std::accumulate(abilities_containers.begin(), abilities_containers.end(), 0);
}double avg() const { return sum() / (double)ABILITIES_MAX; }int max() const { return *max_element(abilities_containers.begin(), abilities_containers.end()); }

看到我们的做法了嘛？对于对象们本身，如果他们就是一个东西（int），或者是我们在关心的上下文中可以转化为同一个东西，那么，我们就把这些对象们集合为一个数组进行处理。

提示：现代C++可以做的更出色一些：

#include <array>
#include <numeric>
#include <algorithm>
#include <functional>
#include <iostream>struct Creature {int strength, agility, intelligence;int get_strength() const { return strength; }int get_agility() const { return agility; }int get_intelligence() const { return intelligence; }
};// 通用 Analyzer：传入一组可调用对象（成员指针 / lambda）
template<typename T, typename... Getters>
class Analyzer {
public:static constexpr std::size_t N = sizeof...(Getters);std::array<int, N> vals;Analyzer(const T& obj, Getters... getters): vals{ std::invoke(getters, obj)... } {}int sum() const { return std::accumulate(vals.begin(), vals.end(), 0); }double avg() const { return sum() / static_cast<double>(N); }int max() const { return *std::max_element(vals.begin(), vals.end()); }
};template<typename T, typename... G>
auto make_analyzer(const T& t, G... g) {return Analyzer<T, G...>(t, g...);
}

关于C++20的编程细节 + 模板编程 + 函数式，笔者打算后续专门开一个博客系列分享。这里感兴趣的朋友可以先自行了解。

简化编程接口——组合共同基类的子类对象为数组

但是上面的条件出现的相对苛刻。我们更多有可能遇到的是——对于具备相同父类的子类集合，绘制的时候完全可以进行聚合，这个例子就很简单——

struct GeoObject {virtual void draw() = 0; }
struct Rectangle : public GeoObject { ... };
struct Circle : public GeoObject { ... }; //struct Group : GeoObject {std::string name;explicit Group(const std::string& name) { ... }void draw() override { for(auto&& each : objects) each->draw();} void add(const GeoObject* p) { objects.emplace_back(p); }
private:std::vector<GeoObject*> objects;
};// process the sessions
Group pRoot("root");
pRoot.add(new Rectangle());Group sub("AnyCast");
sub.add(new Circle());
pRoot.add(&sub);pRoot->draw();