Generic vector of templates - c++

Question

For me generic vectors of templates are vector that can take template with any argument list. Like this
vector<Foo<?>> foos;
foos.push_back(Foo<int>(5));
foos.push_back(Foo<Bar>(Bar()));
foos.push_back(Foo<string>("bar"));
EDIT:
This is why I need this
#ifndef EVENT_DISPATCHER_H
#define EVENT_DISPATCHER_H
// #include <boost/signals2.hpp>
#include <string>
#include <vector>
#include <functional>
#include <map>
namespace Whitedrop {
template <typename... T> class EventDispatcher {
public:
EventDispatcher(std::string eventID)
{
}
void on(std::function<void(T...)> callback)
{
mCallbacks.push_back(callback);
}
void trigger(T&... args)
{
for (auto f : mCallbacks)
f(args...);
}
protected:
std::vector<std::function<void(T...)>> mCallbacks;
};
std::map<std::string, EventDispatcher<?> > dispatchers; // HERE <--------
template<typename... T> void registerListener(std::string eventID, std::function<void(T...)> callback)
{
if (!dispatchers.count(eventID))
{
dispatchers[eventID] = new EventDispatcher<T...>(eventID);
return;
}
dispatchers.find(eventID)->second.on(callback);
//std::shared_ptr<Chunk> chunk = mChunks.find(pos)->second;
}
template<typename... T> void invokeListener(std::string eventID, T... args)
{
if (!dispatchers.count(eventID))
{
return;
}
dispatchers.find(eventID)->second->trigger(args...);
}
};
#endif
SInce it seems not possible, how can I resolve my issue?

Answer 1

No, that is not possible. Class templates are templates, not types. The std::vector template requires a type as its first argument, not a template.
You can use class templates to produce types, but you have to choose one particular type for each instantiation of the std::vector template.
More generally, the nature of a template parameter tells you what kind of argument you can use. In C++ there are three "ontological tiers": values ("things that have types), types ("things that are types), and templates ("things that make any of the three"). Each can appear as a template parameter:
template < int A // Value (int prvalue)
, typename B, // Type
, template <typename> class C // Template
> struct Foo {};
Foo<10, double, std::allocator> foo;
// A B C

Answer 2

Simple answer is no.
The compiler needs to figure out types and sizes.
EDIT
Use inheritance
Eg
class Event {
private:
std::string m_id;
public:
Event(std:string &id) : m_id(id) { }
std:string EveentId() const { return m_id;}
virtual void DoEvent() = 0;
};
class MyEvent : Event {
public:
MyEvent() : Event("MyEvent") { }
DoEvent() { std::cout << "MyEvent" << std::endl;
};
Then have a list of events
i.e.
std::vector<std::shard_ptr<Event>> events;
events.push_back<std::make_shared<MyEvent>());
events[0]->DoEvent();

Answer 3

std::vector is a homogeneous container, which means it can only contain one type. Note that Foo<> is a family of types not a single type, the type of std::vector is different depending on the template parameter.
Now, you can achieve what you want using two methods I can think off, the first is by erasing the type, for example you can use std::vector<boost::any>, but note that it completely erases the type (the type info is lost), and is not a compile time operation.
The second way is using a tuple, this is a compile time fixed-size container, which means you can't add new elements at runtime, because the type of each object is determined at compile time.