an array of templates?

[c coder]

I hope someone with broad knowledge about templates and arrays can direct me on this.

i know how to make a simple template class and use it for different datatypes. i have little knowledge about vector-containers. my question is if it can be possible to have a "container" (im not sure if it is the right definition to use) that stores different datatypes in one array?

if you dont get it i will try make some C++/pseudo-code thing so its easier to understand what im looking for:

container->AddThing<char> (100);
container->AddThing<int> (4000);
container->AddThing<myDataType> (MyDataType(100, 50));

the class of container:

{
    //has a vector?
    std::vector<SomeClass*> array;    //here there must be stored different datatypes

    template <class T> void AddThing(T value)
    {
        array.push(value);
    }
}

so the array should be able to store chars, ints, etc, and also own datatypes(structures). for example on the example above the memory-layout or array would look like this (if it really matters):

array[0] = 100;
array[0+4] = 4000;
array[0+4+DataTypeSize] = 100 and 50;

the memory layout is really not that important for me before I get something to work, i am really just out after storing a template (different datatypes) into an array, so i can easilly access the members with the dot or pointer operator, or by using an iterator.

i need some direction, or what to look for to find the right documentation i can read to learn this, if C++ are able to do this?
(edit: also you see i have SomeClass as the parameter in the vector member, i wonder if SomeClass should be a pure virtual class or something. i am still not a pro in understanding pure virtual classes or functions and if this will be the best way to do it, if its even possible?)

[grumpy]

No, it is not possible to instantiate a template in order to create a container that contains a mix of datatypes, since templates must be instantiated at compile time (i.e. the compiler must be told what types and parameters to instantiate the template for - you can't wait until runtime to instantiate a template with different types/parameters). The standard containers are template classes, so containers (and the types they contain) can only be specified at compile time.

More significantly, it is not possible to change the return type of a function arbitrarily depending on runtime data. The return type of a function can only be determined at compile time. This doesn't change with templates, given the requirement (as above) to instantiate the template at compile time.

How about you explain WHY you have decided you need to do this? It would be unusual to have a requirement for arbitrary data types to be stored contiguously in a single container, that can be stored arbitrarily and and retrieved correctly in arbitrary manners without any bookkeeping (to keep track of what type is stored in what part of the container). Such requirements usually have an element of need for "magic happens somewhere", which is rather hard to code in C++ without making specific assumptions.

[c coder]

How about you explain WHY you have decided you need to do this? It would be unusual to have a requirement for arbitrary data types to be stored contiguously in a single container, that can be stored arbitrarily and and retrieved correctly in arbitrary manners without any bookkeeping (to keep track of what type is stored in what part of the container). Such requirements usually have an element of need for "magic happens somewhere", which is rather hard to code in C++ without making specific assumptions.

Ive decided to do this because of easiness of maintaining and updating code. Since i vant arbitrary datatypes and even own datatypes as in structures. Later when I want a new datatype-structure having to update code that allready does the same thing using templates was/is the thing i wanted to do. Having to bookkeep them would be painfull because of my design. (Id had to change alot on the code and would be too time consuming, and every time i needed a new datatype). I allready have a template class that manipulates the data that is supposed to be putted into some sort of an array. Because all data in this array are supposed to be updated in a loop. And those datas have different datatypes.

[manasij7479]

Ive decided to do this because of easiness of maintaining and updating code. Since i vant arbitrary datatypes and even own datatypes as in structures. Later when I want a new datatype-structure having to update code that allready does the same thing using templates was/is the thing i wanted to do. Having to bookkeep them would be painfull because of my design. (Id had to change alot on the code and would be too time consuming, and every time i needed a new datatype). I allready have a template class that manipulates the data that is supposed to be putted into some sort of an array. Because all data in this array are supposed to be updated in a loop. And those datas have different datatypes.

That doesn't make much sense ..(to me at least) .
Are you sure that you are not over designing and loosing track of what OOP should do ?

If the types you're going to put in the 'array' have some similarity regarding what they're to represent, make a base class and store references to its objects in the array.

[c coder]

manasij: Maybe it didnt make sense because my explanation was very subjective. and the core problem is more complex than that. Doing so by pasting alot of code wouldnt help much either. I was trying to do that with the pseudo-code thingy up there.

Are you sure that you are not over designing and loosing track of what OOP should do ?

That's exactly what im not trying to do.

If the types you're going to put in the 'array' have some similarity regarding what they're to represent, make a base class and store references to its objects in the array.

Yes, they have some similarity. Your suggestion is allready something i've considered looking into. It might work, but i have a hunch its not really what i am out after. I will try if its my last option though. Thanks for the feedback so far. I think i've gotten the answers I needed. That it is not possible or there are noone who can direct me by storing arbitrary datatypes using templates for an array. If its even possible. If it's not possible, then I'd just have to deal with it using other solutions that won't require alot of coding each time i implement a new datatype.

[grumpy]

As you've described it, there is no solution.

That's why I asked you to clarify what you are actually trying to achieve. Your response suggests you have decided you want variant data types, without bookkeeping. But you can't seem to answer my question (what would that "solution" allow you to achieve?) and you also can't explain how variant data types would achieve it.

I can assure you that code is very hard to maintain and update if you can't articulate its purpose, or articulate how it logically meets that purpose better than some other design or coding approach.

[Elysia]

If all you need to do is guard against type changes in the code, then use typedefs. For example, your function takes a MyType_t which you can also use as the type for your containers.
Alternatively, you can also use decltype, which will let the compiler determine the type of some variable which you can use in your containers:

int foo;
std::vector<decltype(foo)> bar;