Clone an object in a polymorphic class?

Hi, I have a question about cloning objects in polymorphic classes:

In a lab we are doing in school we are going to create an expression tree, looking for example like this when it's printed:

Code:

---

    5
  /
  *
  \
    7
 /
+
 \
  6

---

which represents the expression 5*7+6 in tree form. Each node in the tree is of a class called node, then there's a subclass called node_operator. Each class under node is supposed to have a clone function, so that it is possible to clone a whole tree by just cloning the node at the lowest level.

node_operator in turn, is an abstract class which have subclasses called node_plus, node_minus, node_times etc. Each object which is of a derived class from node_operator will have two and only two data members, left_node and right_node. To clone a object from any subclass of node_operator, it will be the exact same code:

Code:

---

node_x* node_x::clone() {
    return new node_x(left_child->clone(), right_child->clone());
}

---

Where x is the name operator. Since x is different for every subclass, the same function can't be used, hence we need a virtual clone function. What I would like to do is something like this (only having to write the function once instead of having to write almost the same code in every subclass):

Code:

---

virtual node_operator* clone();

...

virtual node_operator* node_operator::clone(){
    return new typeof(this*) (left_child->clone(), right_child->clone());
}

---

If only typeof would have existed in C++ (as it does in C) the code would have worked, and the function I mentioned above (that one with node_x) would have successfully been copied to every subclass node_x. But now typeof doesn't exist in C++. Can I use something else instead of typeof, or do I have to write the clone function in every subclass? Having to write the same code in every subclass feels bad. Besides, the risk of creating a bug will increase. Why did they remove typeof from the beginning, when they created C++ from C?

There is no typeof in standard C. Have you learned about templates yet? Maybe you could template it.


Quzah.

Quote:

---

Originally Posted by quzah

There is no typeof in standard C. Have you learned about templates yet? Maybe you could template it.

---

Can you give a pseudo-code how he would do that?

Sounds like a good use of the prototype pattern.
Prototype Design Pattern
There is the UML of how you could design your class structure.

Yes each class needs to know "how" to copy itself.

Are you really supposed to print that for the expression tree? Why? The expression tree would be this:

Code:

---

      +
    / \
    /  \
  *    6
  / \
 /  \
5    7

---

Expression trees can be displayed in many ways, it can also look like this:

Code:

---

        -- 5
      |
    -- *
  |  |
  |    -- 7
  |
-- +
  |
    -- 6

---

But the form I used in the first post was the way our supervisor used as an example, because it is the easiest to program.

Quote:

---

Originally Posted by TriKri

Expression trees can be displayed in many ways, it can also look like this:

Code:

---

        -- 5
      |
    -- *
  |  |
  |    -- 7
  |
-- +
  |
    -- 6

---

But the form I used in the first post was the way our supervisor used as an example, because it is the easiest to program.

---

Oh I see sideways. I was reading it downwards instead of to the right. Carry on then.

As to that, C stole typeof from C++'s typeid, so that shouldn't really be a problem.

This is definitely a candidate for templatization.

Code:

---

template < typename Op >
class BinaryNode
{
public:
    BinaryNode( Node *lhs, Node *rhs )
      : mLhs( lhs ),
        mRhs( rhs )
    {
    }

    Value Evaluate() const
    {
        return Op::Evaluate( lhs->Evaluate(), rhs->Evaluate() );
    }

    BinaryNode *Clone() const
    {
        return new BinaryNode( mLhs->Clone(), mRhs->Clone() );
    }

private:
    Node *mLhs;
    Node *mRhs;
};

---

Now, you can define for instance:

Code:

---

class AdditionOperator
{
public:
    static Value Evaluate( Value lhs, Value rhs )
    {
        return lhs + rhs;
    }
};

---

And then:

Code:

---

typedef BinaryNode< AdditionOperator > AdditionNode;

---

Now, you just have to implement the operators themselves, and forget about cloning.

(My code is not exception safe. In general, none of the examples I give are exception safe unless otherwise claimed)

Thank you brewbuck, I'll remember that next time I get in the same situation!

-Kristofer