如何在C ++中重载模板类的运算符？

Question

I have a binary search tree class (BST.h) and a node class (Node.h) of which works fine when I store data types such as integers in it. My problem is trying store class objects in my BST and use an attribute from the object as the key. My program also has a student class which contains studentID and studentName. How would I write an operator overload in my student class so every time my BST preforms operation on nodes, it will overload to the student.getID(), instead of operating on the object itself. I have the rough idea of what the overload function should look like but i don't know where it should go or if its coded correctly anyway.

//My attempt at an operator overload
bool operator< (const Student &s1, const Student &s2)
{
    return s1.GetID < s2.GetID;
}

//Node.h

#ifndef NODE_H
#define NODE_H

#include <iostream>

using namespace std;

template<class T>
class Node
{
public:

    Node();

    T data;
    Node *left;
    Node *right;
    Node(T);


};

template<class T>
Node<T>::Node()
{
}

template<class T>
Node<T>::Node(T d)
{
    data = d;
    left = NULL;
    right = NULL;
}

#endif //

//BST.h

#ifndef BST_H
#define BST_H
#include <iostream>
#include "Node.h"
#include <string>
using namespace std;

template<class T>
class BST
{
public:

    BST();



    void Insert(T);
    Node<T> *Search(T);
    void preOrder();
    void inOrder();
    void postOrder();



    ~BST();

private:
    Node<T> *root;
    void Insert(T , Node<T> *aNode);
    Node<T> *Search(T, Node<T> *aNode);
    void preOrder(Node<T> *aNode);
    void inOrder(Node<T> *aNode);
    void postOrder(Node<T> *aNode);
};

template<class T>
BST<T>::BST()
{
    root = NULL;
}

template<class T>
void BST<T>::Insert(T data, Node<T> *aNode)
{
    if (data < aNode->data)
    {
        if (aNode->left != NULL)
        {
            Insert(data, aNode->left);
        }
        else
        {
            aNode->left = new Node<T>(data);
            aNode->left->left = NULL;
            aNode->left->right = NULL;
        }
    }
    else
    {
        if (data >= aNode->data)
        {
            if (aNode->right != NULL)
            {
                Insert(data, aNode->right);
            }
            else
            {
                aNode->right = new Node<T>(data);
                aNode->right->left = NULL;
                aNode->right->right = NULL;
            }
        }
    }
}

template<class T>
void BST<T>::Insert(T data)
{
    if (root != NULL)
    {
        Insert(data, root);
    }
    else
    {
        root = new Node<T>(data);
        root->left = NULL;
        root->right = NULL;
    }
}

template<class T>
Node<T>* BST<T>::Search(T data, Node<T> *aNode)
{
    if (aNode != NULL)
    {
        if (data == aNode->data)
        {
            return aNode;
        }

        if (data < aNode->data)
        {
            return Search(data, aNode->left);
        }
        else
        {
            return Search(data, aNode->right);
        }

    }
    else
    {
        return NULL;
    }
}

template<class T>
Node<T>* BST<T>::Search(T data)
{
    return Search(data, root);
}

template<class T>
void BST<T>::preOrder()
{
    preOrder(root);
}

template<class T>
void BST<T>::preOrder(Node<T> *aNode)
{
    if (aNode != NULL)
    {
        cout << aNode->data << " ";
        preOrder(aNode->left);
        preOrder(aNode->right);

    }
}

template<class T>
void BST<T>::inOrder()
{
    inOrder(root);
}

template<class T>
void BST<T>::inOrder(Node<T> *aNode)
{
    if (aNode != NULL)
    {
        inOrder(aNode->left);
        cout << aNode->data << " ";
        inOrder(aNode->right);
    }
}

template<class T>
void BST<T>::postOrder()
{
    postOrder(root);
}

template<class T>
void BST<T>::postOrder(Node<T> *aNode)
{
    if (aNode != NULL)
    {
        postOrder(aNode->left);
        postOrder(aNode->right);
        cout << aNode->data << " ";
    }
}

template<class T>
BST<T>::~BST()
{
}


#endif // !BST_H

//Student.h

#ifndef STUDENT_H
#define STUDENT_H

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
    Student();
    Student(string, int);
    ~Student();
    int Student::GetID();


private:
    string name;
    int ID;
};

inline int Student::GetID()
{
    return ID;
}

Answer 1

You seem to be asking about operator< taking Student s , however Student is not a class template, so the title of your post is baffling.

As someone else pointed out, your operator< is almost correct, except you have to actually call GetID() instead of comparing pointers to member functions.

This won't work yet until you fix GetID however. Instead of int Student::GetID(); it should be:

int GetID() const;

The const means that it can be called on objects passed by const reference, as you have in your operator< implementation. And you don't repeat the Student:: when declaring functions inside the class. (You use it when defining class members outside of the class definition).

Answer 2

Declare it as a friend function within your Student class, next to the rest of your member functions

friend bool operator < (Student& s1, Student& s2);

Your implementation is correct, it should go outside your Student class within the same header file.