强制 Child 类实现深拷贝方法

问：

我有一个父类“Parent”，它需要一个模板参数 K 作为它所操作的数据类型。对于子实现，我想强制它们实现自定义的“deepcopy”方法。

“Runner”类给出了 deepcopy 方法的一个示例用法，该类实质上保存给定 Child 实现的主副本。请注意，在实际示例中，Runner 类型将有多个线程同时访问和更改“master”字段，同时持有锁，因此需要 master 类型的深拷贝。

我目前已经解决了这个问题，如下所示：

#include <iostream>
#include <vector>


template<typename T, typename K>
class Parent{
public:
    virtual void mutate_state(std::vector<K> &data)=0;
    T deepcopy(){
        T res;
        res = static_cast<T&>(*this);
        return res;
    }
};


// some example implementation of Base<T, K>
class Child : public Parent<Child, int>{
private:
    std::vector<int> all_elements;
    int state;
public:
    void mutate_state(std::vector<int> &data) override{
        // do something with data & cfg
        all_elements.insert(all_elements.end(), data.begin(), data.end());
        state++;
        std::cout<<"Called A, state is: "<<state<<std::endl;
    }
    Child(Child &child) {
        std::cout<<"call custom child copy constructor"<<std::endl;
        state = child.state;
    }
    Child& operator=(Child other)
    {
        std::cout<<"call custom child copy assignment"<<std::endl;
        std::swap(state, other.state);
        return *this;
    }
    Child(): state(0){};
};


// an example class mutating the Child
template<typename T, typename K>
class Runner {
private:

    // master Child instance
    T master;
    
public:
    explicit Runner(T child_impl) : master(child_impl) {}

    T get_master_deepcopy() {
        return master.deepcopy();
    }

    void update_master_model(T new_master) {
        master = new_master;
    }

    void update(std::vector<int> &data){
        T temp_deepcopy = get_master_deepcopy();
        temp_deepcopy.mutate_state(data);
        master = temp_deepcopy;
    }
};



int main() {
    Child base_impl;

    // not nice: I have to keep specifying template type K=int although its already been defined in the child implementation
    Runner<Child, int> runner(base_impl);

    std::vector<int> some_data;
    runner.update(some_data);
}

但是，我的实现感觉很麻烦。

• 目前没有在子实现中“强制”自定义复制运算符实现的机制。如果它们被遗忘，使用复杂的动态分配类型的子实现可能只会导致浅拷贝，我想严格避免。
• 我的 Runner 不知道 T 的真正类型，它应该被限制为从类 Parent<T， K 继承>
• 另外，我不喜欢重复声明模板参数 K 的类型 无论是在 Child 的实现中，还是在实例化“Runner”类型时。在实例化“Runner”类型时，有没有办法从已经定义的 Child 类中提取模板类型 K？

如何改进此方法？