如何创建一个向量来保存同一模板类的所有类型的元素

Question

I have a template class:

template<typename A, typename B, typename C>
class blah{...};

I want to create a std::vector<> to save any possible objects of blah.

for example

blah<float, int, string>

or

blah<string, string, char>

those blah objects, although originated from the same template class, are essentially different types. How can I declare a std::vector to save them all?

I thought about using std::variant, but I can't because to use it, I need to enumerate all possible template parameter combinations:

std::variant<all possible template parameter combinations>

I thought about using std::any, I can't because I don't know how to type cast from std::any back to the right type?

I thought about using a base class:

template<typename A, typename B, typename C>
class blah : public blah_base
{...};

and declare a vector like this:

std::vector<blah_base*>

but again, I still don't know how to type cast from blah_base* back to the right type?

Answer 1

Basically, what you need is polymorphism. All of the options you were exploring are polymorphism, and that is the best way for this to be solved. However, you say this and other variations:

I don't know how to type cast from blah_base* back to the right type

If you find yourself needing to do this, you are doing something wrong. Either it doesn't make sense to have a std::vector<blah<...>> , or your blahs all need to meet the blah_base contract.

You could solve this with a virtual function:

class blah_base {
public:
    virtual void foo() = 0;
};

Then, rather than having to tell which type of blah you had, you'd just call the appropriate foo function that does what you want.

Answer 2

Well, without knowing too much about what your use case is I will assume you will have three vectors; one for each template type. You could implement blah as such:

#include <vector>

template<typename A, typename B, typename C>
class blah
{
public:
    // Put stuff here.
    void AddToVectorA(A item);
    void AddToVectorB(B item);
    void AddToVectorC(C item);
private:
    std::vector<A> _a;
    std::vector<B> _b;
    std::vector<C> _c;
};

template<typename A, typename B, typename C>
void blah<A,B,C>::AddToVectorA(A item)
{
    _a.push_back(item);
}

template<typename A, typename B, typename C>
void blah<A,B,C>::AddToVectorB(B item)
{
    _b.push_back(item);
}

template<typename A, typename B, typename C>
void blah<A,B,C>::AddToVectorC(C item)
{
    _c.push_back(item);
}

int main()
{
    blah<int, double, float> b;
    b.AddToVectorA(2);

    return 0;
}

You could also make the three vectors public and people can use them however; you could also look into tuple . FYI: I now tested the code, it works.