Operator Overbelasting met sjablonen binnenkant van een BST

Question

Operator Overbelasting met sjablonen binnenkant van een BST

stemmen

0

Ik heb momenteel een binaire zoekboom setup, met behulp van sjablonen om mij toe om de aard van de gegevens gemakkelijk veranderen binnen de binaire zoekboom. Op dit moment heb ik problemen met overbelasting van de studentRecord klasse die de gegevens moeten worden opgeslagen in de boom bevat. Ik moet de vergelijking operators overbelast binnen deze klasse, zodat mijn BST goed twee objecten kunnen vergelijken op basis van een van hun inhoud (in dit geval, de student-ID). Echter, ondanks overbelasting van de exploitanten binnen studentRecord, goede vergelijkingen zijn nog steeds niet voorkomen.

Details hieronder:

Momenteel heeft de bst object studentTree gecreëerd, type

bst<studentRecord *> studentTree;

studentRecord is de volgende 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;
};

Wanneer er nieuwe items worden toegevoegd aan mijn BST, moeten ze worden met elkaar vergeleken. Daarom wilde ik de studentRecord klasse overbelasten, zodat wanneer deze vergelijking proces plaatsvindt, wordt de studentIDs worden vergeleken (als anders, een ongeldige vergelijking zal worden gemaakt).

Echter, mijn inbrengen functie gebruikt nooit mijn overbelast vergelijking functies. In plaats daarvan lijkt te zijn het vergelijken van de twee objecten op een andere manier, wat resulteert in ongeldige sortering binnen de BST. Een deel van mijn insert functie is hieronder - het is belangrijk op te merken dat zowel toInsert en nodePtr-> gegevens van het type studentRecord zou moeten zijn, als gevolg van de template proces optreedt.

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

Ook hier is een deel van het BST klasse 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.....

Alle ideeën over wat kan dit veroorzaken? Ben ik overbelasting van de verkeerde klasse of de verkeerde functie? Alle hulp wordt gewaardeerd - ik lijken te zijn de weg kwijt omdat er zo veel verschillende dingen zijn die zich in een keer.

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

De vraag is gesteld op 23/02/2011 om 07:09
bron van user BSchlinker

In andere talen...

2 antwoorden

stemmen

2

Je instantiëren uw template class als volgt uit:

bst<studentRecord *> studentTree;

Dus bstType == studentRecord *

Het insert ziet er als volgt dan:

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

zodat je aan het doen zijn een pointer vergelijking en dit is de reden waarom uw operator niet wordt genoemd als Asha allready gewezen.

Meer zodat u overbelasting alleen de operator Groter dan (>), maar jij kunt de minder dan operator (<). Als je echt twee objecten van het type studentRecord in insert zou vergelijken hoort te de code zelfs compileren en moet klagen dat het niet in staat is om een passende minder dan operator vinden.

Meer dus ik kan wijzen op verschillende problemen in uw code:

studentRecord.studentID is van het type tekenreeks? Maar probeer je toewijzen een integer in de constructor. Het gaat hierbij om te zetten de integer naar char en het karakter om de string te wijzen - dus heel waarschijnlijk niet wat je bedoeld.
U mist het minder dan operator.

Hieronder vindt u de code en een aantal thest code die de luchtvaartmaatschappij aantoont wordt aangeroepen bij het vergelijken van twee exemplaren van het type studentRecord. U kunt ook zien wat de gevolgen van de vermiste minder dan operator door commentaar van de definitie operator in de studentRecord klasse zou zijn (-> compileren fout).

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

Als een einde reactie waarschijnlijk zou het een goed idee om de andere vergelijking operators te bieden (> =, <=, == en! =.

antwoordde op 23/02/2011 om 10:29
bron van user ds27680

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

stemmen

1

De auteur van de vraag accepteerde dit antwoord als de beste.

Uw boom is een boom van pointers . Dus wanneer u probeert om een element in te voegen in de boom de waarden van de pointers wordt vergeleken. Dus je overbelast operator heet niet voor niets. Wilt u de overbelaste operator te gebruiken dan moet je makenbst<studentrecord>

antwoordde op 23/02/2011 om 07:14
bron van user Asha