Полиморфизм и шаблонный контейнер.

virtual void Print()

Point Po(1,1);  //просто точка имеет 2 координаты
Pixel Pi(2,3);   //писксел кромее коорд. еще и ставит черный цвет по умолчанию.
Pixel Pi2(12,9,Pixel::Color::red);
 
 
Stack<Point> StackPixel;   //Stack типа template
 
StackPixel.AddObject(Po); //AddObject - добавляет объект в стек.
StackPixel.AddObject(Pi);
StackPixel.AddObject(Pi2);
 
 
for (int i=0; i<StackPixel.KolObject; i++)
{
    StackPixel.MyObject[i].Print(); //выводит в консоль коорд. и цвет.
}

template<class TObject>
Stack<TObject>::Stack()
{ 
    Max=Max_;
    KolObject=0;
    s4=0;
    MyObject = GetMassivObject();
}

template<class TObject>
void Stack<TObject>::AddObject(TObject &Object) 
{ 
 
    //сначала нужно занять память.
    if (KolObject>=Max) 
    {   
        Max = Max << 1;                 //увеличим в 2 раза память 
        MyObject = GetMassivObject();   //Создадим массив.
    }
        //далее добавляем объект в массив объектов.
    *MyObject = Object;
    MyObject[KolObject] = Object; //тут вот объект в массив добавляется!!
    KolObject++;
};

template<class TObject>
class Stack
{
public:
    Stack();
//  void AddObject(TObject &Object); 
    void AddObject(TObject &Object); 
    void Clear();
    int KolObject;
    TObject *MyObject,*GetMassivObject();
 
    ~Stack(); 
private:
    TObject *MyObject2,*MyObject3;
    int Max,s4;
};

MyObject = GetMassivObject();   //Создадим массив.

       *MyObject = Object;
        MyObject[KolObject] = Object; //тут вот объект в массив добавляется!!

//**********************************
template<class TObject>
class NewStack
{
public:
    NewStack(TObject &MyObject) :MyObject_(MyObject) {};
    int KolObject;
    TObject MyObject_;
 
    ~NewStack() {}; 
};
//**********************************

Point Po(1,1);
Pixel Pi(12,9,Pixel::Color::red);
 
NewStack<Point> NewStackPixel(Po);
NewStackPixel.MyObject_.Print();
NewStack<Point> NewStackPixel(Pi);
NewStackPixel.MyObject_.Print(); //вот тут он отрабатывает как поинт. а я хочу чтоб как пиксел

void Point::Print()const
{
    cout << '(' << x_ << ',' << y_ << ')';
}

void Pixel::Print()const
{
    Point::Print();
    cout << "Pixel: " << c_ << endl;
}

virtual void Print()const;

NewStack<Point> NewStackPixel(Pi);
NewStackPixel.MyObject_.Print(); //вот тут он отрабатывает как поинт. а я хочу чтоб как пиксел

NewStack<Pixel> NewStackPixel(Pi);

#include <iostream>
#include <vector>
 
class Object
{
public:
   virtual ~Object()
   {
   }
   virtual void print()
   {
      std::cout << "In base print" << std::endl;
   }
};
 
class Int_Object : public Object
{
public:
   Int_Object(int val):value(val)
   {
   }
   virtual void print()
   {
      std::cout << "In int print: " << value << std::endl;
   }
private:
   int value;
};
 
typedef std::vector<Object*> objects;
 
int main()
{
   objects objs;
   objs.push_back(new Int_Object(5));
   objs.push_back(new Object());
   for (objects::iterator iter = objs.begin(); iter != objs.end(); ++iter)
   {
      (*iter)->print();
   }
   for (objects::iterator iter = objs.begin(); iter != objs.end(); ++iter)
   {
      delete *iter;
   }
}

// https://stackoverflow.com/questions/14235678/c-polymorphic-container-which-can-add-several-objects-at-once
 
#include <iostream>
#include <vector>
#include <memory>
#include <utility> 
 
using namespace std;
 
class Parent
{
public:
   virtual ~Parent() {}
   virtual void print() {
      std::cout << "In Base print" << std::endl;
   }
};
 
class ChildA : public Parent
{
public:
   ChildA(int val, int val2):value(val), value2(val2) {}
   virtual void print() {
      std::cout << "In A print: " << value << ".." << value2 << std::endl;
   }
private:
   int value;
   int value2;
};
 
class ChildB : public Parent
{
public:
   ChildB(int val, int val2):value(val), value2(val2) {}
   virtual void print() {
      std::cout << "In B print: " << value << ".." << value2 << std::endl;
   }
private:
   int value;
   int value2;
};
 
//===================
 
struct VectorCreator
{
  explicit VectorCreator(std::vector<std::unique_ptr<Parent>> &vec)
    : vec_(vec)
  {}
  
    // supports variadic templates
  template <typename Type, typename... ArgType>
  VectorCreator& create(ArgType&&... arg)
  {
    vec_.push_back(std::unique_ptr<Parent>(new Type(std::forward<ArgType>(arg)...)));
    return *this;
  }
 
private:
  std::vector<std::unique_ptr<Parent>> &vec_;
};
 
// ====================
 
int main(int argc, const char *argv[])
{       
    std::vector<std::unique_ptr<Parent>> myvector;
    VectorCreator(myvector).create<ChildA>(1, 2).create<ChildB>(3, 4).create<ChildB>(5, 6);
 
    for(auto& v : myvector) v->print();
    return 0;
}

new Type(std::forward<ArgType>(arg)...)

explicit VectorCreator(std::vector<std::unique_ptr<Parent>> &vec)
  // : vec_(vec)
     : vec_(std::move(vec))
  {}

#include <iostream>
 #include <vector>
 #include <memory>
 #include <iterator>
 #include <algorithm>
using std::cout;
using  std::cin;
using  std::endl;
 
int main() {
    std::vector<std::unique_ptr<int>> up;
    up.emplace_back(new int(1));
    up.emplace_back(new int(2));
 
    std::vector<std::unique_ptr<int>> up1;
    //std::copy(up.begin(), up.end(), std::back_inserter(up1));//eror::use of deleted function...
    std::copy(std::make_move_iterator(up.begin()), std::make_move_iterator(up.end()), std::back_inserter(up1));
        for(const auto &p:up1)
            cout<<*p<<' ';//1 2
return 0;
}