Это правильное применение правила пяти с абстрактным базовым классом и членом unique_ptr?

Попытка устранить ошибку C2248 связанных с абстрактным базовым классом, использующим реализацию операторов копирования / перемещения / операторов присваивания и dtor (правило пяти), и возникает несколько вопросов:

1) Почему правило 5, в первую очередь относящееся к dtor, применяется, когда элементы данных unique_ptr обрабатываются автоматически? Реализация dtor должна быть оставлена ​​правильной, так как unique_ptrs автоматически уничтожается, когда их владельцы выходят из области видимости?

2) Предположим, что другой класс имеет член типа std :: unique_ptr вектора того же типа. Для того чтобы этот класс был копируемым, он должен иметь ctor и оператор копирования, которые клонируют элемент данных unique_ptr? Я видел это решение, но похоже, что оригинальный постер только что переключился на shared_ptr ради удаления ошибки без особого внимания к управлению собственностью. Это правильная стратегия?

3) Рассмотрим тот же случай, что и в вопросе 2 выше, касающемся вектора unique_ptr. Должен ли dtor включать вызов clear () вектора?

4) Операторы присваивания для Derived1 не верны. Но в базовом классе должны быть операторы копирования и перемещения, поскольку в нем есть операторы копирования / перемещения (правило 4/5). Они не могут быть использованы вне класса, так как он абстрактный и, следовательно, экземпляры не будут назначены. Но как мне использовать этот код из производных классов? Каждый производный класс должен иметь возможность перемещать / копировать базовые элементы данных и свои собственные элементы данных. Я не уверен, что делать.

    #include <algorithm>
#include <memory>
#include <vector>
#include <iostream>

class Base{

public:
Base() : m_subBases(){};

/*  copy ctor */
Base(const Base& other) : m_subBases(){
*this = other;
};

/*  move ctor */
Base(Base&& other) : m_subBases(){
*this =std::move( other);
};

/*  Move assignment operator*/
Base& operator=(Base&& other){
m_subBases = std::move(other.m_subBases);
return *this;
};

/*  Copy assignment operator */
Base& operator=(const Base& other){
for(int i = 0; i < other.m_subBases.size(); i++)
m_subBases.push_back(other.m_subBases[i]->clone());

return *this;
};

/* virtual dtor */
virtual ~Base(){
m_subBases.clear();
};

/* Used for creating clones of unique_ptrs */
virtual std::unique_ptr <Base> clone() const= 0;

/* Do something */
virtual void execute(float f) = 0;

//Omitted data member access methods

protected:
std::vector < std::unique_ptr <Base> > m_subBases;
};

class Derived1 : public Base{

public:
Derived1() :  Base(){};

/*  copy ctor */
Derived1(const Derived1& other) : Base(other){
*this = other;
};

/*  move ctor */
Derived1(Derived1&& other) : Base(std::move(other)){
*this = std::move(other);
};

/*  Move assignment operator*/
Derived1& operator=(Derived1&& other){

//This is redundant when called in the move ctor because
// of the call to Base(std::move(other))
m_subBases = std::move(other.m_subBases);

m_string = other.m_string;
return *this;
};

/*  Copy assignment operator */
Derived1& operator=( const Derived1& other){

//This is redundant when called in the copy ctor because
// of the call to Base(other)
for(int i = 0; i < other.m_subBases.size(); i++)
m_subBases.push_back(other.m_subBases[i]->clone());

m_string = other.m_string;
return *this;
};

/* virtual dtor */
virtual ~Derived1(){};

/* Used for creating clones of unique_ptrs */
virtual std::unique_ptr <Base> clone() const{
return std::unique_ptr <Base> (new Derived1(*this));
};

virtual void execute(float f){
std::cout << "Derived1 " << f << std::endl;
};
protected:

std::string m_string;
};