使用多态集合

Question

我的情况如下：

    #include <set>
    #include <map>
    #include <vector>
    #include <string>

    class BaseCollection {
        // I don't know what to keep here
        // I want to have access to collection elements
        // seems I need to implmement begin(), end() for collections
    };

    class CollectionA : public BaseCollection {
        public: // in real code this will be private
            std::vector<double> coll_;
    };

    class CollectionB : public BaseCollection {
        public: // in real code this will be private
            std::set<double> coll_;
    };

    class CollectionC : public BaseCollection {
        public: // in real code this will be private
            std::map<std::string, double> coll_;
    };

    class Base {
        public:
            virtual BaseCollection* getColl() = 0;
    };

    class A : public Base {
        virtual BaseCollection* getColl() { return &coll_; }
        public: // in real code this will be private
            CollectionA coll_;
    };

    class B : public Base {
        virtual BaseCollection* getColl() { return &coll_; }
        public: // in real code this will be private
            CollectionB coll_;
    };

    class C : public Base {
        virtual BaseCollection* getColl() { return &coll_; }
        public: // in real code this will be private
            CollectionC coll_;
    };

    class Container {
        public:
        typedef std::map<std::string, Base*>::const_iterator const_iterator;
        Container::const_iterator begin() const { return objects_.begin(); }
        public: // in real code this will be private
            std::map<std::string, Base*> objects_;
    };


    int main() {
        // somewhere we're creating objects of different types and filling their collections
        A objA;
        // suppose we filled objA.coll_ somehow
        Base* ptrA = new A;
        ptrA = &objA;

        // somwhere we're iterationg over Container
        Container c;
        c.objects_["objA"] = ptrA;
        Container::const_iterator itBeg = c.begin();
        BaseCollection* coll = itBeg->second->getColl();
        // and here I want to itarate over collection
}

所以，我需要以某种方式至少为BaseCollection 定义begin()、end() 并在派生类中实现它们。
或者也许我需要使用模板？但我想不通。
我该怎么做？
或者这不可能，我需要为每种类型保留单独的容器（A、B、C）。

编辑： 所以，我拥有的是一个Base 类，以及一些从它派生的类（A、B、C），它们包含不同类型的集合。实际上我想要的是Base 中的一个接口来迭代它当前指向的派生类的集合。

提前致谢。

Answer 1

如果您希望能够以基本类型或类型 a、b 或 c 的形式访问元素。多态是要走的路。但是你不应该从集合中继承。所以你的基本类型应该是这样的：

class baseType{
    //define share parameters here like:
    int baseInt;
    //and pure virtual functions like:
    int elementType() = 0;
}

您的收藏将如下所示：

class BaseCollection {
    std::list<baseType> baseList;
 };

继承类型如下所示：

 class typeA:baseType{

 //a pure virtual has to be overridden so:
 int elementType() { return 1;}
 }

请注意，集合将始终返回 baseType 类型的元素。如果您想知道继承的类型是什么。有两种方法可以做到这一点。

• 对 baseType 的指针进行静态转换，转换为所需的类型。如果类型不是所需的类型，这将返回 null。
• 创建一个（纯）虚函数，它返回一个整数或其他类型的变量，指示类型。就像上面那样。

当继承类型过多时，您可能想要执行后者。因为会有很多 static_casts

Answer 2

编辑： 您可以为 BaseCollection 实现一个迭代器的并行层次结构 Base 迭代器类，并为每个派生集合类实现一个迭代器。 同样，当迭代器之间的值类型不同时，您可以将通用值类型定义为某种变体或将所有内容都返回为字符串。

这不是微不足道的。您必须在每个特定类的开始/结束和每个派生迭代器中实现值访问函数、复制/比较等运算符。

创建你的类型值（不是集合）的基类并将指向对象的指针存储在标准容器中不是更容易吗？

原创 使用模板进行代码重用

使用多态提供相同的接口并隐藏实现

在您的情况下，您在派生类中使用具有不同类型的不同容器。它只是一个例子，还是应该这样？如果是第二个，模板在这里将无济于事。

实现开始/结束不是问题，例如virtual void begin() =0; 派生类中的实现应该设置一些私有索引或迭代器指向您特定容器中的位置。

还有一个问题，你会返回哪种类型？一种变体可能是一种解决方案。