Overloading degli operatori con i modelli all'interno di un BST

Question

Overloading degli operatori con i modelli all'interno di un BST

voti

0

Al momento ho un binario di configurazione albero di ricerca, utilizzando i modelli per permettermi di cambiare facilmente il tipo di dati all'interno del albero binario di ricerca. Al momento, sto avendo problemi di sovraccaricare la classe studentRecord che contiene i dati da memorizzare nella struttura. Ho bisogno di sovraccaricare gli operatori di confronto all'interno di questa classe, in modo che il mio BST può confrontare correttamente due oggetti in base a uno dei loro contenuti (in questo caso, lo studente ID). Tuttavia, nonostante il sovraccarico degli operatori all'interno studentRecord, il confronto corretto non sono ancora verificando.

Dettagli qui di seguito:

Al momento, è stata creata la studentTree oggetto BST, di tipo

bst<studentRecord *> studentTree;

studentRecord è la seguente classe:

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

Ogni volta che vengono aggiunti nuovi elementi al mio BST, devono essere confrontati tra loro. Quindi, ho voluto sovraccaricare la classe studentRecord, in modo che quando si verifica questo processo di confronto, i studentIDs vengono confrontati (come altrimenti, un confronto valido sarà resa).

Tuttavia, la mia funzione di inserimento non usa mai le mie funzioni di confronto overload. Invece, sembra essere a confronto i due oggetti in qualche altro modo, con conseguente smistamento valida all'interno del BST. Parte della mia funzione di inserimento è al di sotto - è importante notare che sia toInsert e nodePtr-> dati dovrebbero essere di tipo studentRecord, a causa del processo si verificano template.

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

Inoltre, ecco una parte della classe di defintion BST

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

Tutte le idee su ciò che può essere la causa? Sto sovraccaricare la classe sbagliata o la funzione sbagliata? Ogni aiuto è apprezzato - mi sembra di essere perdersi dato tante cose diverse si verificano in una sola volta.

c++templates operator-overloading binary-tree binary-search-tree

È pubblicato 23/02/2011 alle 07:09
fonte dall'utente BSchlinker

In altre lingue...

2 risposte

voti

2

Si istanzia la classe template in questo modo:

bst<studentRecord *> studentTree;

Così bstType == studentRecord *

L'inserto si presenta così, allora:

template<studentRecord*>
void bst<studentRecord*>::insert(studentRecord*& toInsert, bst<studentRecord*>::bstNodePtr & nodePtr);

così si sta facendo un confronto puntatore e questo è il motivo per cui l'operatore non è chiamato come Asha giá sottolineato.

Più così sovraccaricate solo il maggiore operatore di (>), ma in inserto si utilizza l'operatore Minore di (<). Se volete davvero confrontare due oggetti di tipo studentRecord a inserire il codice should't anche compilare e dovrebbe lamentano che non è in grado di trovare un adeguato meno di operatore.

Più così posso sottolineare diversi problemi nel codice:

studentRecord.studentID è di tipo stringa? Tuttavia si tenta di assegnare un numero intero nel costruttore. Questo semplicemente convertire il numero intero in char e assegnare il carattere alla stringa - in modo molto probabilmente non è quello desiderato.
Ti manca l'operatore Minore di.

Qui di seguito il codice e un codice thest che dimostra l'operatore viene chiamato quando si confrontano due istanze di tipo studentRecord. Si può anche vedere che cosa sarebbe gli effetti della scomparsa meno di operatore commentando la definizione dell'operatore nella classe studentRecord (- errore> compilazione).

class studentRecord
{
public:

    studentRecord(int studentID) : studentID(studentID)
    { 
    }

    bool operator > (studentRecord &record)
    {
        return (studentID > record.studentID);
    }

    /* Uncomment to get rid of the compile error!
    bool operator < (studentRecord &record)
    {
        return studentID < record.studentID;
    }
    */

private:
    // student information
    int studentID;
};

int main()
{
    studentRecord r1(10);
    studentRecord r2(5);

    if ( r1 < r2 )
    {
        cout << "It works! " << "r1 less than r2" << endl;
    }
    else
    {
        cout << "It works! " << "r1 greater than r2" << endl;
    }

    if ( r1 > r2 )
    {
        cout << "It works! " << "r1 greater than r2" << endl;
    }
    else
    {
        cout << "It works! " << "r1 less than r2" << endl;
    }
}

Come commento finale probabilmente sarebbe una buona idea per fornire gli altri operatori di confronto troppo (> =, <=, == e! =.

Risposto il 23/02/2011 a 10:29
fonte dall'utente ds27680

Asha · Accepted Answer · 2011-02-23 07:14

voti

1

L'autore ha accettato questa risposta come la migliore.

L'albero è un albero di puntatori . Così, quando si tenta di inserire un elemento nella struttura i valori dei puntatori viene confrontato. Così il vostro operatore di overload non è chiamato. Se si desidera utilizzare l'operatore sovraccaricato allora si dovrebbe crearebst<studentrecord>

Risposto il 23/02/2011 a 07:14
fonte dall'utente Asha