Operatør Overbelastning med maler innsiden av en BST

Jeg har for tiden et binært søketre oppsett, bruk maler for å tillate meg å enkelt endre typen data i binært søketre. I øyeblikket, jeg har problemer med å overbelaste studentRecord klassen som inneholder dataene som skal lagres i treet. Jeg trenger å overbelaste sammenligningsoperatorene innenfor denne klassen, slik at min BST kan riktig sammenligne to objekter basert på en av sine innholdet (i dette tilfellet, student ID). Men til tross for overbelastning operatørene innen studentRecord, riktige sammenligninger er fortsatt ikke forekommer.

Detaljer nedenfor:

For øyeblikket har bst objektet studentTree blitt skapt, av type

bst<studentRecord *> studentTree;

studentRecord er følgende klasse:

// 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;
};

Når nye elementer er lagt til min BST, må de sammenlignes med hverandre. Derfor ville jeg å overbelaste studentRecord klassen, slik at når denne sammenligningsprosessen oppstår, blir studentIDs sammenlignes (som ellers en ugyldig sammenlikning vil bli gjort).

Men bruker min innsetting funksjon aldri mine overbelastet sammenligning funksjoner. I stedet ser det ut til å være å sammenligne de to objektene annen måte, noe som resulterer i et ugyldig sortering i BST. En del av min innsats funksjon er under - det er viktig å merke seg at både toInsert og nodePtr-> data bør være av typen studentRecord, på grunn av templating prosessen oppstår.

// 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);
    }

Også her er en del av BST klassen definisjonen

// 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.....

Noen ideer om hva som kan være årsaken til dette? Er jeg overbelaste feil klasse eller feil funksjon? Alle hjelpe er verdsatt - jeg synes å være å få tapt siden så mange forskjellige ting som skjer på en gang.