Opérateur Surcharger avec des modèles à l'intérieur d'un BST

J'ai actuellement une configuration d'arbre de recherche binaire, en utilisant des modèles pour me permettre de changer facilement le type de données dans l'arbre de recherche binaire. En ce moment, je vais avoir du mal à surcharger la classe studentRecord qui contient les données à stocker dans l'arborescence. Je dois surcharger les opérateurs de comparaison au sein de cette classe, de sorte que mon BST peut bien comparer deux objets en fonction de l'un de leur contenu (dans ce cas, l'étudiant). Cependant, en dépit de la surcharge des opérateurs au sein studentRecord, les comparaisons appropriées sont encore ne se produisent pas.

Détails ci-dessous:

À l'heure actuelle, l'objet studentTree bst a été créé, de type

bst<studentRecord *> studentTree;

studentRecord est la classe suivante:

// studentRecord class
class studentRecord{
public:
    // standard constructors and destructors
    studentRecord(int studentID, string lastName, string firstName, string academicYear){ // constructor
        this->studentID=studentID;
        this->lastName=lastName;
        this->firstName=firstName;
        this->academicYear=academicYear;
    }

    friend bool operator > (studentRecord &record1, studentRecord &record2){
        if (record1.studentID > record2.studentID)
            cout << Greater! << endl;
        else
            cout << Less then! << endl;
        return (record1.studentID > record2.studentID);
    }

private:
    // student information
    string studentID;
    string lastName;
    string firstName;
    string academicYear;
};

Chaque fois que de nouveaux éléments sont ajoutés à mon BST, ils doivent être comparés entre eux. Par conséquent, je voulais surcharger la classe studentRecord, de sorte que lorsque ce processus de comparaison se produit, les studentIDs sont comparés (sinon, une comparaison non valide sera).

Cependant, ma fonction d'insertion utilise jamais mes fonctions de comparaison surchargées. Il semble plutôt être de comparer les deux objets d'une autre manière, ce qui invalide le tri dans le BST. Une partie de ma fonction d'insertion est inférieure à - il est important de noter que les deux toInsert et nodePtr-> données doivent être de type studentRecord, en raison du processus de templating survenant.

// insert (private recursive function)
template<typename bstType>
void bst<bstType>::insert(bstType & toInsert, bstNodePtr & nodePtr){
    // check to see if the nodePtr is null, if it is, we've found our insertion point (base case)
    if (nodePtr == NULL){
        nodePtr = new bst<bstType>::bstNode(toInsert);
    }

    // else, we are going to need to keep searching (recursive case)
    // we perform this operation recursively, to allow for rotations (if AVL tree support is enabled)
    // check for left
    else if (toInsert < (nodePtr->data)){ // go to the left (item is smaller)
        // perform recursive insert
        insert(toInsert,nodePtr->left);

        // AVL tree sorting
        if(getNodeHeight(nodePtr->left) - getNodeHeight(nodePtr->right) == 2 && AVLEnabled)
            if (toInsert < nodePtr->left->data)
                rotateWithLeftChild(nodePtr);
            else
                doubleRotateWithLeftChild(nodePtr);
    }

De plus, voici une partie de la classe BST défintion

// BST class w/ templates
template <typename bstType>
class bst{

private: // private data members

    // BST node structure (inline class)
    class bstNode{
    public: // public components in bstNode

        // data members
        bstType data;
        bstNode* left;
        bstNode* right;

        // balancing information
        int height;

        // constructor
        bstNode(bstType item){
            left = NULL;
            right = NULL;
            data = item;
            height = 0;
        }

        // destructor
        // no special destructor is required for bstNode     
    };

    // BST node pointer
    typedef bstNode* bstNodePtr;

public: // public functions.....

Toutes les idées sur ce qui pourrait être la cause? Suis-je SURCHARGE la mauvaise classe ou la mauvaise fonction? Toute aide est appréciée - je semble se perdre puisque tant de choses différentes se produisent à la fois.