Создание коллекции объектов разных классов

template <> class OneDirList1 <class ,class CX2, class CX3>
{
public:
        CX1 nValue1;
    CX2 nValue2;
    CX3 nValue3;
    OneDirList1 *pNext;
        OneDirList1* addToList(CX1 nValue1,CX2 nValue2,CX3 nValue3)
    {
        OneDirList1 * pList,*pNew;
        pList=this;
        pNew=new OneDirList1(NULL);
        pNew->nValue1=nValue1;
        pNew->nValue2=nValue2;
        pNew->nValue3=nValue3;
        pNew->pNext=pList;
        return pNew;
    };

OneDirList1 <CX1,CX2,CX3> p;

template <class  CX1, class CX2, class CX3>
class OneDirList1
{
public:
    CX1 nValue1;
    CX2 nValue2;
    CX3 nValue3;
    OneDirList1 *pNext;
    OneDirList1* addToList(CX1 nValue1,CX2 nValue2,CX3 nValue3)
    {
        OneDirList1 * pList,*pNew;
        pList=this;
        pNew=new OneDirList1(NULL);
        pNew->nValue1=nValue1;
        pNew->nValue2=nValue2;
        pNew->nValue3=nValue3;
        pNew->pNext=pList;
        return pNew;
    }
};
int main()
{
     OneDirList1 <int, double, char> p;
}

template <class CX1,class CX2, class CX3> class OneDirList1 
{
public:
    X nValue1;
    OneDirList1 *pNext;
OneDirList1* addToList(X_nValue1)
    {
        OneDirList1 * pList,*pNew;
        pList=this;
        pNew=new OneDirList1(NULL);
        pNew->nValue1=_nValue1;
 
        pNew->pNext=pList;
        return pNew;
    };
};

#include <iostream>
#include <list>
#include <memory>
 
class Base
{
public:
    virtual std::ostream& print(std::ostream& ost = std::cout) const
    {
        return ost << "Base";
    }
};
 
class Derived1 : public Base
{
public:
    std::ostream& print(std::ostream& ost = std::cout) const
    {
        return ost << "Derived1";
    }
};
 
class Derived2 : public Base
{
public:
    std::ostream& print(std::ostream& ost = std::cout) const
    {
        return ost << "Derived2";
    }
};
 
int main()
{
    std::list<std::shared_ptr<Base>> list;
    list.emplace_back(new Base);
    list.emplace_back(new Derived1);
    list.emplace_back(new Derived2);
    std::cout << list.size() << std::endl;
    for(auto const& p : list)
        p->print() << std::endl;
    return 0;
}

#include <iostream>
#include <list>
#include <memory>
 
 
template<typename T>
struct my_list {
   
   typedef std::list<T>                               container_type;
   typedef typename container_type::const_iterator    const_iterator;
   
   
   const_iterator begin() const {
      return container.begin();
   }
   
   const_iterator end() const {
      return container.end();
   }
   
   
   template<typename ...Args>
   void emplace_back(Args && ...args) {
      container.emplace_back(std::forward<Args>(args)...);
   }
   
   
private:
   container_type container;
};
 
 
struct base {
   
   virtual void call() const {
      std::clog << "base call" << std::endl;
   }
   
   virtual ~base() {}
};
 
struct left : base {
   
   virtual void call() const {
      std::clog << "left call" << std::endl;
   }
};
 
struct right : base {
   
   virtual void call() const {
      std::clog << "right call" << std::endl;
   }
};
 
 
typedef std::unique_ptr<base> ptr_type;
typedef my_list<ptr_type>     ptr_container_type;
 
 
int main() {
   ptr_container_type container;
   
   container.emplace_back(new base);
   container.emplace_back(new left);
   container.emplace_back(new right);
   
   for (auto const& ptr : container) {
      ptr->call();
   }
}

#include <iostream>
#include <list>
#include <string>
#include <memory>
 
   
struct base {
   
   explicit base(int a) : a(a) {}
   
   virtual std::string to_string() const {
      return std::string("a = ") + std::to_string(a);
   }
   
   virtual ~base() {}
   
private:
   int a;
};
 
struct left : base {
   
   left(int a, float b) : base(a), b(b) {}
   
   virtual std::string to_string() const {
      return base::to_string() + std::string(", b = ") + std::to_string(b);
   }
   
private:
   float b;
};
 
struct right : base {
   
   right(int a, std::string const& c) : base(a), c(c) {}
   
   virtual std::string to_string() const {
      return base::to_string() + std::string(", c = ") + c;
   }
   
private:
   std::string c;
};
 
 
typedef std::unique_ptr<base> ptr_type;
typedef std::list<ptr_type>   ptr_container_type;
 
 
int main() {
   ptr_container_type container;
   
   container.emplace_back(new base(23));
   container.emplace_back(new left(17, .56f));
   container.emplace_back(new right(-3, "YAY"));
   
   for (auto const& ptr : container) {
      std::cout << ptr->to_string() << std::endl;
   }
}