C ++如何在shared_ptrs的向量中存储多个类型？

Question

How can I store in a std::vector multiple shared_ptr each one with a pointer to a different type?

std::vector < ? > vec;
vec.push_back( make_shared<int>(3));
vec.push_back( make_shared<float>(3.14f));

Is there a base polymorphic class that can I use for that task without having to use compiler-specific stuff?

Answer 1

There are a few ways you can do this. I assume you want to store various native types, as you're using int and float.

1. If your list of types is finite, use boost::variant . eg

    std::vector<std::shared_ptr<boost::variant<int, float>>>; 

2. If you want to store anything, use boost::any . eg

    std::vector<std::shared_ptr<boost::any>>; 

Answer 2

I you really need to do exactly this, use boost::any .

And use std::vector <std::shared_ptr<boost::any> > vec;

Answer 3

You can't mix types like that. You may want to have a look at boost::any

Answer 4

No, C++ does not have a single type from which everything is derived like many other languages do. int and float are native types , meaning they are fundamental to the language and not derived from anything else.

If you have the benefit of Boost, you can store any or variant types in your vector instead.

Answer 5

I need at least 1 shared_ptr to keep resources alive

For this to work, all the types you store must inherit from the same base class, which is the same type as the type contained in the shared pointer. Additionally, the base class must declare a virtual destructor (see this question ).

Using boost::any will mean that every other shared_ptr to the objects also has to be a shared_ptr<bsst::any> , which is likely not what you want.

Answer 6

A possible way I figured to solve that is by doing the following

class ISomething{
    bool isAlive;
public:
    virtual bool alive(){ return isAlive;}
    virtual ~ISomething() {}
};

template <typename T>
class Something: public ISomething{
    std::shared_ptr<T> myRes;
public:    
};

std::vector<ISomething*> myVec; //push back a new dynamic allocation for each "Something"

That's basically type erasure, the same concept behind " Boost::Any " " Poco::Any " " Ogre::Any "