Operátor Přetížení se šablonami uvnitř BST

I v současné době mají binární nastavení vyhledávací strom, s využitím šablon, aby mi snadno změnit typ dat v binárním vyhledávacím stromu. V současné době mám potíže přetížení třídu studentRecord, který obsahuje data, která mají být uloženy ve stromu. Musím přetížení operátorů porovnání v rámci této třídy, takže můj BST může správně porovnat dva objekty, založené na jednom z jejich obsah (v tomto případě student ID). Navzdory přetěžování operátorů v studentRecord, správné srovnání jsou stále nedochází.

Podrobnosti níže:

V tuto chvíli byl vytvořen BST objekt studentTree, typu

bst<studentRecord *> studentTree;

studentRecord je následující třída:

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

Kdykoli jsou nové položky přidány do mého BST, musí být ve srovnání s sebou. Proto jsem chtěl přetížení třídu studentRecord, tak, že když nastane toto srovnání proces se studentIDs se porovnávají (jinak, neplatný srovnání bude).

Nicméně, můj funkce vkládání nikdy využívá mé přetížené porovnávací funkce. Místo toho se zdá, že porovnávání dvou objektů jinudy, což má za následek neplatné třídění v BST. Část mé vložky funkce je nižší - to je důležité si uvědomit, že jak toInsert a nodePtr-> údaje by měly být typu studentRecord, vzhledem k šablon procesů vyskytující.

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

Také zde je část BST třídy defintion

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

Jakékoli myšlenky na to, co může být příčinou? Jsem přetížení nesprávnou třídu nebo špatnou funkci? Jakákoliv pomoc je oceňována - Připadá mi, že se ztratí, protože tolik různých věcí, se vyskytují najednou.