Контейнер из неоднородных элементов

 class TElement
{ public:
TElement *nxt;
TElement() { nxt=NULL;}
      virtual ~TElement() {cout<<"Delete TElement.";}
      virtual void Print()=0;
     };
class TQueue
{
public:
  TQuue();//конструктор
  ~TQueue();  //деструктор
  TElement *First(){return cur=first;}
  TElement *Last(){return cur=last;}
  TElement *Next(){return cur=cur->nxt;}
  void addEL(TElement *val);//добавление элемента
  void delEL(); //удаление 1 элем
   void print();
private:
 TElement *first,*last,*cur;
 };
   TQueue::TQuue() //конструктор
   {first=last=cur=NULL;}
 TQueue::~TQueue()  //деструктор
 {TElement *cur1;
  cur1=first;
     while (cur!=NULL) {
     cur=cur1->nxt;
     delete(cur1);
                        }
   }
  void TQueue::addEL(TElement *e)  //добавление элемента
 {
  if (first==NULL)
        { first=last=e; e->nxt=NULL;}
   else
   { e->nxt=first;first=e;}
 }
 
 void TQueue::delEL()
  {//удаление 1 элем
   first=first->nxt;
  }
 
 void TQueue::print()
  {
    cur=first;
      while (cur!=NULL)
      {cur->Print(); cur=cur->nxt;}
  }
 //--------------------------------------------
 class TNum:public TElement
 { 
 public:
 int num;
    TNum(int n):TElement(),num(n) {}
    virtual ~TNum() {cout<<"Delete TNum.";}
    virtual void Print() { printf("%d ",num); }
      };
//--------------------------------------------
 class TSlovo:public TElement
 { public:
       char s[20];
    TSlovo(char *S):TElement() {strcpy(s,S);}
    virtual ~TSlovo() {cout<<"Delete TChar.";}
    virtual void Print() { printf("%s ",s);}
 };
 
class TQueueS: public TQueue
{
 public:
 void sort(TElement * first);
};
void TQueueS::sort(TElement * first)
{ int i;
 TElement *a; TElement *b; char tmp[20];  TSlovo *A;TSlovo *B;
 a = first;
 while ((A =dynamic_cast<TSlovo *>(a))==0)
     a=a->nxt;//продвигаемся до 1-го элемента-строки
 while(a->nxt) // пока существует следующий элемент
 {
   b = a->nxt;
   while(b)  // для каждого элемента перебираем все оставшееся справа
      {
       while ((B=dynamic_cast<TSlovo *>(b))==0 )
          { b=b->nxt;   if (!b) return;}; //продвигаемся до 1-го элемента-строки
      if(strcmp(A->s,B->s)>0)//если порядок не тот - меняем
        { strcpy(tmp, A->s);strcpy(A->s,B->s); strcpy(B->s,tmp); }
        b = b->nxt;
      }
      while ((A =dynamic_cast<TSlovo *>(a))==0)
         a = a->nxt;  //продвигаемся до следующего элемента-строки
 }
}

while ((A =dynamic_cast<TSlovo *>(a))==0)
         a = a->nxt;

#include <string>
#include <typeinfo>
#include <cassert>
#include <vector>
#include <iostream>
 
enum type{E_STRING, E_DOUBLE};
 
class Data
{
public:
   virtual type getType() const = 0;
protected:
   type m_type;
};
 
template <class T>
class Element : public Data
{
public:
   Element( const T& data ) : m_data( data )
   {
      if( typeid(double) == typeid(T) ) 
         m_type = E_DOUBLE; 
      else if ( typeid(std::string) == typeid(T) ) 
         m_type = E_STRING; 
      else
         assert(!"invalid type!");
   }
   virtual type getType() const
   {
      return m_type;
   }
   T getValue()
   {
      return m_data;
   }
private:
   T m_data;
};
 
int main()
{
   std::vector<Data*> v;
   for( int i=0;i<5;++i )
   {
      v.push_back( new Element<double>(3.14 * i) );
   }
 
   v.push_back( new Element<std::string>("hello") );
   v.push_back( new Element<std::string>("world") );
   
   typedef std::vector<Data*>::iterator VIt;
   
   for( VIt it = v.begin(); it != v.end(); ++it )
   {
      if( E_STRING == (*it)->getType() )
         std::cout << 
           dynamic_cast<Element<std::string>*>(*it)->getValue()
                   << " ";
      else 
          std::cout << 
           dynamic_cast<Element<double>*>(*it)->getValue()
                   << " ";
   }
}

#include <iostream>
#include <string>
#include <list>
 
class basic_element
{
public:
    virtual ~basic_element () {}
    
    friend std::ostream & operator << (std::ostream & stream, const basic_element & e)
    {
        return e.print_to_stream(stream);
    }
    
private:    
    virtual std::ostream & print_to_stream (std::ostream & stream) const = 0;
};
 
template <typename Value>
class element : public basic_element
{
public:
    typedef Value value_type;
    
    element ()
    {
    }
    
    element (const Value & value):
        value(value)
    {
    }
   
private:
    virtual std::ostream & print_to_stream (std::ostream & stream) const
    {
        return stream << value;
    }
    
public:
    value_type value;
};
 
int main()
{
    typedef std::list<basic_element *> container_type;
    container_type elements;
    
    elements.push_back(new element<int>(17));
    elements.push_back(new element<std::string>("qwe"));
    
    for (container_type::iterator i = elements.begin(); i != elements.end(); ++i)
    {
        std::cout << **i << std::endl;
    }
    
    for (container_type::iterator i = elements.begin(); i != elements.end(); ++i)
    {
        delete *i;
    }
    
    return 0;
}