Generic container where type is known only at runtime

[Terence Wilson]

I'm having trouble designing a container for all the basic types(char,
int, float, double). The container should be able to hold contiguous
arrays of type T. I would like some kind of generic iterator for
accessing the data that is type independent in order that I could
write generic algorithms.

Basically I need something like std::vector that does not require a
compile type.

I could use some kind of Variant for each element, but the overhead
would be huge since all the elements have the same type.

[Juha Nieminen]

Terence Wilson wrote:

I'm having trouble designing a container for all the basic types(char,
int, float, double). The container should be able to hold contiguous
arrays of type T. I would like some kind of generic iterator for
accessing the data that is type independent in order that I could
write generic algorithms.

Basically I need something like std::vector that does not require a
compile type.

Exactly how do you determine at runtime (instead of at compile time)
the type you need the vector to be of?

[=?iso-8859-1?q?Erik_Wikstr=F6m?=]

On 11 Maj, 06:45, Terence Wilson <[e-mail]:

I'm having trouble designing a container for all the basic types(char,
int, float, double). The container should be able to hold contiguous
arrays of type T. I would like some kind of generic iterator for
accessing the data that is type independent in order that I could
write generic algorithms.

Basically I need something like std::vector that does not require a
compile type.

I could use some kind of Variant for each element, but the overhead
would be huge since all the elements have the same type.

I'm not sure what exactly you are trying to achieve, but I think you
need to create wrappers for the basic types that all derive from a
common baseclass and store pointers to the baseclass in a container.

--
Erik Wikström

[Gianni Mariani]

On May 11, 2:45 pm, Terence Wilson <[e-mail]:

I'm having trouble designing a container for all the basic types(char,
int, float, double). The container should be able to hold contiguous
arrays of type T. I would like some kind of generic iterator for
accessing the data that is type independent in order that I could
write generic algorithms.

Basically I need something like std::vector that does not require a
compile type.

I could use some kind of Variant for each element, but the overhead
would be huge since all the elements have the same type.

This should be quite easy - create a template wrapper around a
std::vector. It's like a boosy any (or Austria C++ Any class for a
vector).

What kinds of things do you envisage doing with it ?

[Thomas J. Gritzan]

Terence Wilson schrieb:

I'm having trouble designing a container for all the basic types(char,
int, float, double). The container should be able to hold contiguous
arrays of type T. I would like some kind of generic iterator for
accessing the data that is type independent in order that I could
write generic algorithms.

Basically I need something like std::vector that does not require a
compile type.

I could use some kind of Variant for each element, but the overhead
would be huge since all the elements have the same type.

What about:

boost::variant< std::vector<char>, std::vector<int>, std::vector<double?

So you don't have a variant for the elements but for the vector.

--
Thomas
http://www.netmeister.org/news/learn2quote.html