C2678: Fehler beim Einfügen der binären Suchbaum C++

Question

Mit Visual Studios 2015 für C++ Implementierung Ich erhalte einen Kompilierungsfehler in meinem insertHelper().

Insert Helper ist eine rekursive Funktion, die unten aufgeführt ist.

template < typename DataType, typename KeyType > 
    void BSTree<DataType, KeyType>::insertHelper(BSTreeNode *&p, 
    const DataType &newDataItem) 

    // Recursive helper function for insert. Inserts newDataItem in 
    // the subtree pointed to by p. 

{ 
    if (p == NULL) { 
     p->dataItem = newDataItem; 
     p->left = NULL; 
     p->right = NULL; 
    } 
    else { 
     if (p->dataItem < newDataItem) { // <- error triggers here 
      insertHelper(p->left, newDataItem); 
     } 
     else { 
      insertHelper(p->right, newDataItem); 
     } 
    } 
} 

Insert Helper wird durch Einsatz hier genannt:

template < typename DataType, typename KeyType > 
    void BSTree<DataType, KeyType>::insert(const DataType &newDataItem) 

// Inserts newDataItem into a tree. If an data item with the same key 
// as newDataItem already exists in the tree, then updates that 
// data item's data with newDataItem's data. 

{ 
    insertHelper(root, newDataItem); 
} 

und eine vereinfachte Version meiner Bäume Header-Datei hier.

#ifndef BSTREE_H 
#define BSTREE_H 
#include <stdexcept> 
#include <iostream> 
using namespace std; 

template < typename DataType, class KeyType > // DataType : tree data item 
class BSTree          // KeyType : key field 
{ 
public: 

    // Constructor 
    BSTree();       // Default constructor 
    // Binary search tree manipulation operations 
    void insert(const DataType& newDataItem); // Insert data item 
protected: 
    class BSTreeNode     // Inner class: facilitator for the BSTree class 
    { 
    public: 

     // Constructor 
     BSTreeNode(const DataType &nodeDataItem, BSTreeNode *leftPtr, BSTreeNode *rightPtr); 

     // Data members 
     DataType dataItem;   // Binary search tree data item 
     BSTreeNode *left, // Pointer to the left child 
      *right; // Pointer to the right child 
    }; 

    // Recursive helpers for the public member functions -- insert 
    // prototypes of these functions here. 
    void insertHelper(BSTreeNode *&p, const DataType &newDataItem); 

    // Data member 
    BSTreeNode *root; // Pointer to the root node 
}; 

#endif // define BSTREE_H 

Testdaten und Initialisierung:

class TestData 
{ 
    public: 

    void setKey (int newKey) 
     { keyField = newKey; } // Set the key 

    int getKey() const 
     { return keyField; }  // Returns the key 

    private: 

    int keyField;    // Key for the data item 
}; 

int main() 
{ 
    BSTree<TestData,int> testTree; // Test binary search tree 
    TestData testData;    // Binary search tree data item 
} 

Ich verstehe nicht, warum ich nicht if (p->dataItem < newDataItem){} verwenden können. Ich habe versucht if (p.dataItem < newDataItem){} und sogar nur if (dataItem < newDataItem){}. Und ich komme mit diesem Bug nicht schnell voran. Jede Hilfe wäre willkommen.

Der Fehler lautet:

C2678: binary '<': kein Operator gefunden, die einen linken BST Operanden des Typs 'Testdata' nimmt (oder es ist kein akzeptabler Umsatz).

Answer 1

if (p->dataItem < newDataItem) { // <- error triggers here 

Basis auf

BSTree<TestData,int> testTree; 

wissen wir, dass p->dataItem und newDataItem vom Typ sind TestData.

So ist der Vergleich erweitert oben

if (p->dataItem.operator<(newDataItem)) 

nun wieder sehen Sie die Fehlermeldung läßt:

binary '<': no operator found which takes a left-hand BST operand of type 'TestData' (or there is no acceptable conversion). 

Es wurde für einen binären '<' Betreiber sucht. Sie haben keine angegeben, sodass die Sprache den von Ihnen angeforderten Vergleich < nicht implementieren kann.

class TestData 
{ 
    public: 

    void setKey (int newKey) 
     { keyField = newKey; } // Set the key 

    int getKey() const 
     { return keyField; }  // Returns the key 

    bool operator < (const TestData& rhs) const 
     { return keyField < rhs.keyField; } 

    private: 

    int keyField;    // Key for the data item 
}; 

oder

class TestData 
{ 
    public: 

    void setKey (int newKey) 
     { keyField = newKey; } // Set the key 

    int getKey() const 
     { return keyField; }  // Returns the key 

    friend bool operator < (const TestData&, const TestData&); 

    private: 

    int keyField;    // Key for the data item 
}; 

bool operator < (const TestData& lhs, const TestData& rhs) 
{ 
    return lhs.keyField < rhs.keyField; 
} 

Live-Demo: http://ideone.com/Y7JGCD