I'm making a tree that has several different node types: a binary node, a unary node, and a terminal node. I've got an ABC that all the nodes inherit from. I'm trying to write a recursive copy constructor for the tree like so:
class gpnode
{
public:
gpnode() {};
virtual ~gpnode() {};
gpnode(const gpnode& src) {};
gpnode* parent;
}
class bnode:gpnode
{
public:
bnode() {//stuff};
~bnode() {//recursive delete};
bnode(const bnode& src)
{
lnode = gpnode(src.lnode);
rnode = gpnode(src.rnode);
lnode->parent = this;
rnode->parent = this;
}
gpnode* lnode;
gpnode* rnode;
}
class unode:gpnode
{
public:
unode() {//stuff};
~unode() {//recursive delete};
unode(const unode& src)
{
node = gpnode(src.node);
node->parent = this;
}
gpnode* node;
}
My problem is that I can't do
node = gpnode(src.node);
because gpnode is a virtual class. I could do
node = unode(src.node);
but that doesn't work when the child of a unode is a bnode. How do I get it to intelligently call the copy constructor I need it to?
You need to implement cloning.
class base
{
public:
virtual base* clone() const = 0;
}
class derived : public base
{
public:
derived(){}; // default ctor
derived(const derived&){}; // copy ctor
virtual derived* clone() const { return new derived(*this); };
};
Etceteras
To do this you have to provide a clone
-method for your objects, that returns a pointer of the appropriate type. If all your classes have copy-constructors, that is as simple as that:
node* clone() const {
return new node(*this);
}
Where node
is the class you are writing the clone
-method for. You would of course have to declare that method in your base-class:
virtual gpnode* clone() const = 0;
Use virtual constructor.
来源:https://stackoverflow.com/questions/7912994/c-calling-a-copy-constructor-on-an-unknown-derived-class-through-an-abstract-b