Przenoszenie unikalnych wskaźników pomiędzy kontenerami z użyciem konstruktora kopiującego

#include <iostream>
#include <memory>
#include <vector>
using namespace std;

class Parent
{
public:
    int a;
    int b;
   
    Parent() { }
   
    Parent( int a, int b )
    {
        this->a = a;
        this->b = b;
    }
   
    Parent( const Parent & copy )
    {
        this->a = copy.a;
        this->b = copy.b;
        std::cout << "Konstruktor kopiujacy -> Parent\n";
    }
   
    Parent( Parent && p )
        : a( std::move( p.a ) )
         , b( std::move( p.b ) )
    { std::cout << "Konstruktor przenoszacy -> Parent\n"; }
   
    virtual int getSum() { return a + b; }
   
};

class Sub
    : public Parent
{
public:
    int c;
   
    Sub() { }
   
    Sub( int a, int b, int c )
    {
        this->a = a;
        this->b = b;
        this->c = c;
    }
   
    Sub( const Sub & copy )
    {
        this->a = copy.a;
        this->b = copy.b;
        this->c = copy.c;
        std::cout << "Konstruktor kopiujacy -> Sub\n";
    }
   
    Sub( Sub && s )
    {
        Sub::a = std::move( s.a );
        Sub::b = std::move( s.b );
        Sub::c = std::move( s.c );
        std::cout << "Konstruktor przenoszacy -> Sub\n";
    }
   
    int getSum() { return a + b + c; }
};

using namespace std;
typedef std::vector < std::unique_ptr < Parent >> Kontener;

int main()
{
    Kontener kontener1, kontener2;
   
    kontener1.push_back( make_unique < Parent >( 1, 1 ) );
    kontener1.push_back( make_unique < Parent >( 2, 2 ) );
    kontener1.push_back( make_unique < Sub >( 1, 1, 1 ) );
    kontener1.push_back( make_unique < Sub >( 2, 2, 2 ) );
   
    for( int i = 0; i < kontener1.size(); ++i )
         cout << kontener1[ i ]->getSum() << endl;
   
    system( "pause" );
    system( "cls" );
   
    kontener2.push_back( make_unique < Sub >( move( kontener1[ 2 ] ) ) ); // ???????????????
   
    system( "pause" );
    return 0;
}