C++ 在复合/迭代器设计模式中看不到真正的价值

理论上，我的情况可能非常适合复合设计模式和迭代器设计模式，但这些模式存在的问题是无法访问底层数据结构，这可能会破坏交易

当然，我可以在一个国家的一个城市的购物中心开一家店，这就形成了整体-部分关系，如果我制作了它的复合模式，我可以在所有对象上运行通用方法（大多数情况下），比如商店/购物中心的开门和关门时间，但实际上我们需要的不仅仅是这些

以一个简单的任务为例，将这种复合结构从已保存的文件加载到树控件中。现在我们甚至不知道哪个组件是什么，所以我们甚至不能确定一个组件应该是树中的父组件、同级组件还是子组件。我们基本上必须做一些类型检查，以找出哪种组合模式首先是反对的。对于外部迭代器尤其如此

起初，这两种模式的结合似乎有更大的潜力，但现在它们似乎用处不大

我试图找到这两种模式的真正正当性。除了像

Print（）。当从文件加载复合文件时，必须将复合文件类型转换回树控件以反映复合文件的层次结构，这是对的吗？
您不需要，您需要

迭代器用于统一的对象；你的物体绝对不一致。此外，当对象以统一的方式使用时，它的效果会更好。一个经典的例子是您计算的表达式；另一个是在屏幕上渲染的几何图形。同样，您的案例不适合经典的复合模式，因为商店和县没有太多的共同点

幸运的是，visitor解决了所有问题：定义一个visitor类，它知道如何处理城市、县、商场和商店。使这些类中的每一个都“可访问”，并将它们排列在一个组合中。现在，组合中类的统一属性是每个类都可以访问。叶类将回调访问者，并将自身作为参数传递。分支类将首先传递它们自己，然后将访问者传递给它们的所有组件。这将使您能够以一种漂亮、干净的方式遍历整个层次结构

class County;
class City;
class Mall;
class Shop;

struct ShoppingVisitor {
    virtual void visitCounty(const County& county);
    virtual void visitCity(const City& city);
    virtual void visitMall(const Mall& mall);
    virtual void visitShop(const Shop& shop);
};
struct ShoppingVisitable {
    virtual void accept(ShoppingVisitor& visitor) const;
};
class County : public ShoppingVisitable {
    vector<ShoppingVisitable*> children;
public:
    virtual void accept(ShoppingVisitor& visitor) const {
        visitor.visitCounty(*this);
        for (int i = 0; i != children.size() ; i++) {
            children[i]->accept(visitor);
        }
    }
};
class City : public ShoppingVisitable {
    vector<ShoppingVisitable*> children;
public:
    virtual void accept(ShoppingVisitor& visitor) const {
        visitor.visitCity(*this);
        for (int i = 0; i != children.size() ; i++) {
            children[i]->accept(visitor);
        }
    }
};
struct Mall : public ShoppingVisitable {
    virtual void accept(ShoppingVisitor& visitor) const {
        visitor.visitMall(*this);
    }
};
struct Shop : public ShoppingVisitable {
    virtual void accept(ShoppingVisitor& visitor) const {
        visitor.visitShop(*this);
    }
};

类县；
三级城市；
类商场；
高级商店；
结构购物访客{
虚拟无效访问国家（康斯特县和县）；
虚拟虚视（const City&City）；
虚拟虚拟虚拟参观商场（康斯特购物中心和购物中心）；
虚拟虚拟虚拟参观商店（施工车间和车间）；
};
结构ShoppingVisiable{
虚拟无效接受（购物访客和访客）常量；
};
类别县：公共购物可访问{
媒介儿童；
公众：
虚拟无效接受（购物访客和访客）常量{
visitor.visitCounty（*本）；
for（int i=0；i！=children.size（）；i++）{
儿童[i]->接受（访客）；
}
}
};
类别城市：公共购物可访问{
媒介儿童；
公众：
虚拟无效接受（购物访客和访客）常量{
visitor.visitCity（*本）；
for（int i=0；i！=children.size（）；i++）{
儿童[i]->接受（访客）；
}
}
};
struct Mall:公共购物可访问{
虚拟无效接受（购物访客和访客）常量{
visitor.visitMall（*本）；
}
};
结构商店：可访问的公共商店{
虚拟无效接受（购物访客和访客）常量{
visitor.visitShop（*本页）；
}
};
你不需要一个，你需要一个

迭代器用于统一的对象；你的物体绝对不一致。此外，当对象以统一的方式使用时，它的效果会更好。一个经典的例子是您计算的表达式；另一个是在屏幕上渲染的几何图形。同样，您的案例不适合经典的复合模式，因为商店和县没有太多的共同点

幸运的是，visitor解决了所有问题：定义一个visitor类，它知道如何处理城市、县、商场和商店。使这些类中的每一个都“可访问”，并将它们排列在一个组合中。现在，组合中类的统一属性是每个类都可以访问。叶类将回调访问者，并将自身作为参数传递。分支类将首先传递它们自己，然后将访问者传递给它们的所有组件。这将使您能够以一种漂亮、干净的方式遍历整个层次结构

class County;
class City;
class Mall;
class Shop;

struct ShoppingVisitor {
    virtual void visitCounty(const County& county);
    virtual void visitCity(const City& city);
    virtual void visitMall(const Mall& mall);
    virtual void visitShop(const Shop& shop);
};
struct ShoppingVisitable {
    virtual void accept(ShoppingVisitor& visitor) const;
};
class County : public ShoppingVisitable {
    vector<ShoppingVisitable*> children;
public:
    virtual void accept(ShoppingVisitor& visitor) const {
        visitor.visitCounty(*this);
        for (int i = 0; i != children.size() ; i++) {
            children[i]->accept(visitor);
        }
    }
};
class City : public ShoppingVisitable {
    vector<ShoppingVisitable*> children;
public:
    virtual void accept(ShoppingVisitor& visitor) const {
        visitor.visitCity(*this);
        for (int i = 0; i != children.size() ; i++) {
            children[i]->accept(visitor);
        }
    }
};
struct Mall : public ShoppingVisitable {
    virtual void accept(ShoppingVisitor& visitor) const {
        visitor.visitMall(*this);
    }
};
struct Shop : public ShoppingVisitable {
    virtual void accept(ShoppingVisitor& visitor) const {
        visitor.visitShop(*this);
    }
};

类县；
三级城市；
类商场；
高级商店；
结构购物访客{
虚拟无效访问国家（康斯特县和县）；
虚拟虚视（const City&City）；
虚拟虚拟虚拟参观商场（康斯特购物中心和购物中心）；
虚拟虚拟虚拟参观商店（施工车间和车间）；
};
结构ShoppingVisiable{
虚拟无效接受（购物访客和访客）常量；
};
类别县：公共购物可访问{
媒介儿童；
公众：
虚拟无效接受（购物访客和访客）常量{
visitor.visitCounty（*本）；
for（int i=0；i！=children.size（）；i++）{
儿童[i]->接受（访客）；
}
}
};
类别城市：公共购物可访问{
媒介儿童；
公众：
虚拟无效接受（购物访客和访客）常量{
visitor.visitCity（*本）；
for（int i=0；i！=children.size（）；i++）{
儿童[i]->接受（访客）；
}
}
};
struct Mall:公共购物可访问{
虚拟无效接受（购物访客和访客）常量{
visitor.visitMall（*本）；
}
};
结构商店：可访问的公共商店{
虚拟无效接受（购物访客和访客）常量{
visitor.visitShop（*本页）；
}
};
一个符合stl的复合外部迭代器示例，请参见github上的此存储库。它是一个正向迭代器*国际热核实验堆返回ba