Список из элементов разного типа

[mMAg]

Добрый день, уважаемые форумчане.

Появился у меня новый вопросик. Кто-нибудь встречал список из элементов разного типа? (Вариант не предлагать, не катит, нужна именно шаблонная реализация.)Или, возможно, может дать какие-то рекомендации по реализации. Наработки выкладывать не буду, поскольку выкладывать некомпилирующийся код это не есть хорошо, я считаю. Если появится что-то близкое к тому, что мне нужно, обязательно выложу.

Заранее спасибо за помощь.

З.Ы. с++, разделом не ошибся )

[Syuf]

Можно на массиве void*'ов, что-то типа:

class IndifList
{
private:
   list<void*> data;

public:
   template <typename T>
   IndifList& operator += (T &obj)
   {
      data.push_back(reinterpret_cast<void*>(new T(obj)));
      return *this;
   }

   template <typename T>
   const T& Back() const
   {
       return *reinterpret_cast<T*>(data.back());
   }
};

И про деструктор не забудьте.

[Blade]

Вариант - унаследовать все нужные типы от одного базового класса не устраивает?

[mMAg]

Сообщение от Blade

Вариант - унаследовать все нужные типы от одного базового класса не устраивает?

Нет, к сожалению.

Пишу сейчас код по void*, если все заработает, тогда будет просто шикарно.

[mMAg]

Syuf, спасибо большое. Впервые на форуме мне действительно очень сильно помогли ))

Вот весь код, может кому понадобится. Правда, с памятью тут могут быть проблемы, жаль, что я плюсы не слишком хорошо знаю, чтобы точно сказать, не будет ли утечек. Если кому-то интересно, посмотрите, пожалуйста.

//---------------------------------------------------------------------------

#include <vcl.h>
#include <iostream.h>
#pragma hdrstop

//---------------------------------------------------------------------------

#ifndef TypeListH
#define TypeListH
//---------------------------------------------------------------------------
#endif

class NullType
{
};

template<class T, class U>
struct TypeList
{
    typedef T Head;
    typedef U Tail;
};

template<class TList>
struct Length;

template <>
struct Length<NullType>
{
    enum
    {
        value = 0
    };
};

template <class T, class U>
struct Length< TypeList<T,U> >
{
    enum
    {
        value = 1 + Length<U>::value
    };
};

template< class TList, int Index>
struct TypeAt;

template <class TList, int Index>
struct TypeAt
{
    typedef typename TypeAt<typename TList::Tail, Index - 1>::Result Result;
};

template <class T, class U>
struct TypeAt<TypeList<T, U>, 0>
{
    typedef T Result;
};

template< class TList >
class IndifList
{
private:
    void** data;
    int len;

public:

    IndifList()
    {
        int len = Length<TList>::value;
        data = new void*[len];
    }

    ~IndifList()
    {
        for (int i = 0; i < len; i++)
        {
            delete data[i];
        }
        delete[] data;
    }

    template<int Index>
    TypeAt<TList, Index>::Result & Get()
    {
        return *reinterpret_cast<TypeAt<TList, Index>::Result*>(data[Index]);
    }

    template<int Index>
    void Set( TypeAt<TList, Index>::Result & value )
    {
        data[Index] = reinterpret_cast<void*>(new TypeAt<TList, Index>::Result(value));
    }

};

#define TypeList_1(T1) TypeList< T1, NullType >
#define TypeList_2(T1,T2) TypeList< T1, TypeList_1(T2) >
#define TypeList_3(T1, T2, T3) TypeList< T1, TypeList_2(T2, T3) >


//---------------------------------------------------------------------------

#pragma argsused
int main(int argc, char* argv[])
{
    IndifList<TypeList_3(int,float, AnsiString)> list;
    int i = 1;
    float b = 2.2;
    AnsiString s = "fdf";
    list.Set<0>(i);
    list.Set<1>(b);
    list.Set<2>(s);
    cout << list.Get<0>() << " " << list.Get<1>() << " " << list.Get<2>().c_str() << endl;
    system("pause");
    return 0;
}
//---------------------------------------------------------------------------