Huh? How would a bst<Bcome up if you have a bst<A*>?
the binary search tree has to work with every type. I'm going to write
with more details the exercise.
Premise: I know it's exactly what an stl tree does, but since it's a
didactic exercise we have to implement it by ourself, without using
stl library.
The exercise consists to define a template of a container, with
minimal operations of insertion, search and erasing.
Then we have to define a class hierarchy that use the container. So I
defined something like i wrote before:
class A {}
class B : public A {}
class C : public A {}
Since every object A, B, C, could be inside the container at runtime,
I have to allocate the bst as bst<A*>. But this is a *particular*
allocation for the exercise. The bst should keep his generalization.
The problem comes when I've to compare objects inside a method of the
bst. If they are allocated as objects there's no problem; they are
compared by their operators. But if they are pointers, they are
compared with their address. I want to dereference them in that case
to use comparing operators of the objects they point.
Here's an example:
template <class T>
void BinarySearchTree<T>::recInsert(Node<T>* root, const T& value) {
if (value < root->info)
if (root->left == 0)
root->left = new Node<T>(value, root);
else
recInsert(root->left, value);
else
if (root->right == 0)
root->right = new Node<T>(value, root);
else
recInsert(root->right, value);
}// recInsert
if the value is a pointer, the addresses are compared instead of
objects.
I've read I could use a functor in the bst template, to define a
custom comparison function. Is that a correct way? Where could I find
a good example to know how I could use a functor in my case? (I
googled it a few yesterday but I didn't find a good explanation)
thanks.
