хранение двух разных объектов класса в векторе

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

Если 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()); 

boost::variant это путь при хранении нескольких различных типов, на которых вы не можете использовать наследование.

Answer 2

Вы можете использовать boost::variant. Это тип, который может представлять собой конечный набор типов, в вашем примере вы бы иметь

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

Альтернативы (который на самом деле не соответствовать вашему USECASE, но может для будущих читателей) является 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) намного чище.