C++ Generic Tree Comparing by Two Criteria - c++

Question

I am starting to work on a generic tree and I am new to C++. I want to be able to form two trees of the same elements, but in each tree to compare in a different manner. From what I could tell if I overload < then I can only define one function. I thought I could perhaps pass a pointer to a function, but I feel like this is the wrong way to go about this.
template<class T, int (*Comp)(T*, T*)> class Tree
What would be an advisable way to try and do that?
Thanks

Answer 1

No, you do not want to specify a pointer to a function (doing so would prohibit using a function object, which is usually preferable).
The template parameter should normally be a type parameter--and in this case you almost certainly want to provide a default of std::less<T>, so it would look something like this:
template <class T, class Comp = std::less<T>>
class Tree {
// Implementation here.
};
This will allow instantiation over a pointer to a function, but (as noted above) will also support a function object.
Note, however, that the template parameter only specifies the type of thing you use to do comparisons. In a typical case, you'll need an instance of that type to do something. You'll typically specify this when you construct your object, so you'll have something like this:
template <class T, class Comp = std::less<T>>
class Tree {
public:
Tree(Comp c = Comp()) : c(c) {}
bool insert(T value) {
if (c(value, root->value)) // if value < root->value
// ...
else if (c(root->value, value)) // if root->value < value
}
private:
struct Node {
T key;
Node *left , *right;
} *root;
Comp c;
};
So, the template parameter specifies the type for the thing that does a comparison. We give it a default of std::less<T>; that'll work nicely for built-in types, and anything else that makes a<b a legitimate expression (assuming we want the comparison that does, of course). If we supply a different type, it's up to use to ensure that it defines a strict weak ordering.
We then pass an instance of the comparison type to the constructor. Again, we specify a default value of a default-constructed instance of that type. For the common case of a function object type like std::less<T> or std::greater<T>, a default constructed object will do the right thing, so that's all we need.
For the less common case of wanting to use a pointer to a function, we have to specify the correct type as the template parameter, and we have to pass a pointer to the correct function to the constructor.