在向量

Question

我试图找到一种好方法在一个向量中存储两个不同的类对象，每个对象在向量中拥有它自己的位置，因此可以在需要时存储和访问对象。

我使用了一个结构，但后来我将结构所有的东西都存储到了矢量中，这不是我想要的，我将举例说明我的意思。

Class A{
   public:
     void changeNumber(int x) {number = x;}
   private:
     int number;
};

Class B{
   public:
     void changeNumber(int x) {number = x;}
   private:
     int number;
};

struct Object{
   A a;
   B b;
};

Class Main{
   public:
     void storeObject(Object ob) {object.push_back(ob);}
   private:
     std::vector<Object> objects; //when an object is passed both A and B objects are stored within the vector in the same location
};

有没有办法可以在一个对象中存储两个不同的类对象，但一次只能传递一个以便存储，所以我在向量中拥有它自己的索引？

Answer 1

如果rule和A具有共同的功能，并且您只在向量的元素上调用这些函数，则可以使用所有通用成员和成员函数并创建基类它的。然后制作B和A派生类B：

Object

在这种情况下，class Object { public: virtual ~Object() = default; void changeNumber(int x) { number = x; } private: int number; }; class A : public Object { // extension of Object }; class B : public Object { // extension of Object }; 与A没有区别，因此所有内容都在B中实现。

最后，你的矢量将如下所示：

Object

这里有更优选的std::vector<Object*> objects; 解决方案，在从向量中删除元素或以其他方式销毁元素后，为您释放内存。

std::shared_ptr

存储对象：

std::vector<std::shared_ptr<Object>> objects;

void storeObject(std::shared_ptr<Object> const& ob) { objects.push_back(ob); } // Example calls Main main; main.storeObject(std::make_shared<Object>(A())); // store A main.storeObject(new A()); // logically same as above main.storeObject(std::make_shared<Object>(B())); // store B main.storeObject(new B()); 是存储多个不能使用继承的不同类型的方法。

Answer 2

您可以使用boost::variant。它是可以表示有限类型集的类型，在您的示例中，您将具有

std::vector<boost::variant<A,B> > objects;

替代方案（不适合您的用例，但可能适合未来的读者）是boost::any。如果在编译时没有可能类型的有限列表，它可以表示任何有用的类型。

Answer 3

如果您更喜欢使用自己的“variant等效”。你可以按照

的方式做点什么

struct Object{ 
    std::shared_ptr<A> a; 
    std::shared_ptr<B> b;
};

std::vector<Object> objects;

Object one; 
one.a = std::make_shared<A>();
objects.push_back(one);

Object two; 
two.b = std::make_shared<B>();
objects.push_back(two);

for(auto object: objects) {
     if(object.a) {
          object.a->changeNumber(1);
     } else if(object.b) {
          object.b->changeNumber(2);
     }
}

但是，我仍然认为用适当的继承方案解决这个问题（如在the other answer中）更清晰。