Forcing Child class to implement deep-copy methods - c++

Question

I have a parent class "Parent" which requires a template parameter K for the data type it operates on. For the child implementations, I'd like to force these to implement a custom "deepcopy" method.
An example use of the deepcopy method is given by the "Runner" class, which essentially holds a master copy of a given Child implementation. Note that in a real-world example, the Runner type would have multiple threads accessing and mutating the "master" field simultaneously while holding a lock, hence the need for deep-copies of the master type.
I've currently solved this as follows:
#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);
}
However, my implementation feels cumbersome.
There is currently no mechanism to "force" an implementation of custom copy operators in a child implementation. If they are forgotten, a child implementation which uses complex dynamically allocated types may only lead to shallow copy which I want to strictly avoid.
My Runner is unaware of the true type of T which should be restricted to inherit from the class Parent<T, K>
Also, I dislike the need to repeatedly declare the type of template parameter K
both in the implementation of Child as well when instantiating the "Runner" type. Is there a way to extract the template type K from the already defined Child class when instantiating the "Runner" type?
How can I improve this approach?