Question

使用Visual Studio 2015进行C ++实现我在insertHelper()收到编译错误。

Insert Helper是一个下面列出的递归函数。

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

插入助手通过插入来调用：

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

我的树头文件的简化版本就在这里。

#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

测试数据和初始化：

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
}

我不明白为什么我不能使用if (p->dataItem < newDataItem){}。我试过了if (p.dataItem < newDataItem){}，甚至只是if (dataItem < newDataItem){}。而且我对这个错误无法快速发展。任何帮助，将不胜感激。

错误如下：

C2678：binary'＆lt;'：找不到运算符，它接受'TestData'类型的左手BST操作数（或者没有可接受的转换）。

Answer 1

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

基于

BSTree<TestData,int> testTree;

我们知道p->dataItem和newDataItem的类型为TestData。

所以上面的比较扩展到

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

现在让我们再看一下错误信息：

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

它正在寻找二进制'＆lt;'运营商。您尚未提供，因此该语言无法实现您请求的<比较。

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

或

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

现场演示：http://ideone.com/Y7JGCD

C2678：插入二进制搜索树c ++时出错

1 个答案: