重载运算符 +：表达式必须具有整数或无作用域的枚举类型

Question

我正在编写一些使用链表的代码，但我很难确定为什么我的 + 运算符不起作用，我不断收到上述错误。

我错过了什么？

#include <iostream>
#include <string>
using namespace std;

struct sortedListNode
{
    char letter;
    int occurrences = 1;
    sortedListNode *next;
};

sortedListNode *operator+(sortedListNode *lhs, sortedListNode *rhs)
{

    int i = 0;
    sortedListNode *head, *tail, *curr, *prev, *tempLoc;
    sortedListNode *list1, *list1curr, *list2, *list2curr;
    list1 = lhs;
    list2 = rhs;

    // Copy list1 into output list

    head = new sortedListNode;
    head->letter = list1->letter;
    head->occurrences = list1->occurrences;
    head->next = NULL;
    tail = head;

    list1curr = list1;
    list1curr = list1curr->next;

    while (list1curr != NULL)
    {
        tempLoc = new sortedListNode;
        tempLoc->letter = list1curr->letter;
        tempLoc->occurrences = list1curr->occurrences;
        tempLoc->next = NULL;

        tail->next = tempLoc;
        tail = tempLoc;

        list1curr = list1curr->next;
    }

    curr = head;
    while (list2curr != NULL)
    {

        while (curr != NULL)
        {

            if (curr->letter == list2curr->letter)
            {
                curr->occurrences++;
                break;
            }
            else if ((curr->letter > list2curr->letter) && (curr == head))
            {
                tempLoc = new sortedListNode;
                tempLoc->next = curr;
                tempLoc->letter = list2curr->letter;
                head = tempLoc;
                break;
            }
            else if ((curr->letter > list2curr->letter) && (curr != head))
            {
                tempLoc = new sortedListNode;
                tempLoc->next = curr;
                tempLoc->letter = list2curr->letter;
                prev->next = tempLoc;
                break;
            }
            else if ((curr == tail) && (curr->letter < list2curr->letter))
            {
                tempLoc = new sortedListNode;
                tempLoc->next = NULL;
                tempLoc->letter = list2curr->letter;
                tail->next = tempLoc;
                tail = tempLoc;
                break;
            }

            prev = curr;
            curr = curr->next;

        }

        curr = head;
        list2curr = list2curr->next;
    }


    return head;


}

sortedListNode *fromString(string inWord)
{

    int i = 0;
    sortedListNode *head, *tail, *curr, *prev, *tempLoc;

    // Put the first letter in as the first element, set head and
    // tail to this element.
    head = new sortedListNode;
    tail = head;

    head->letter = inWord[0];
    head->next = NULL;

    curr = head;
    for (int i = 1; inWord[i] != '[=10=]'; i++)
    {
        while (curr != NULL)
        {

            if (curr->letter == inWord[i])
            {
                curr->occurrences++;
                break;
            }
            else if ((curr->letter > inWord[i]) && (curr == head))
            {
                tempLoc = new sortedListNode;
                tempLoc->next = curr;
                tempLoc->letter = inWord[i];
                head = tempLoc;
                break;
            }
            else if ((curr->letter > inWord[i]) && (curr != head))
            {
                tempLoc = new sortedListNode;
                tempLoc->next = curr;
                tempLoc->letter = inWord[i];
                prev->next = tempLoc;
                break;
            }
            else if ((curr == tail) && (curr->letter < inWord[i]))
            {
                tempLoc = new sortedListNode;
                tempLoc->next = NULL;
                tempLoc->letter = inWord[i];
                tail->next = tempLoc;
                tail = tempLoc;
                break;
            }

            prev = curr;
            curr = curr->next;

        }

        curr = head;

    }

    return head;
}

void printList(sortedListNode *inSortedListNode)
{
    sortedListNode *curr;
    curr = inSortedListNode;
    int nodeCounter = 0;

    while (curr != NULL)
    {
        nodeCounter++;
        cout << "Node " << nodeCounter << " at " << curr << " - Letter = " << curr->letter << ", Occurrences = " << curr->occurrences << ", Next Node = "
            << curr->next << endl;
        curr = curr->next;
    }


}

int main()
{

    string word1, word2;

    sortedListNode *list1;
    sortedListNode *list2;
    sortedListNode *list3;

    cout << "Enter first word: ";
    cin >> word1;
    cout << "Enter second word: ";
    cin >> word2;

    list1 = fromString(word1);
    cout << "Letter list from word one: " << endl;
    printList(list1);

    list2 = fromString(word2);
    cout << "Letter list from word two: " << endl;
    printList(list2);

    list3 = list1 + list2;
    cout << "Letter list from both words: " << endl;
    printList(list3);


    cin.ignore(32767, '\n');

    char dummy[1]{};

    cin.getline(dummy, 1);



}

请注意，我知道运算符定义中存在错误，因为我尚未完成编写。我正在尝试克服将两个链表 sortedListNode 对象作为参数的障碍。

这是作业。主线是讲师提供的存根主线。运算符 + 应该取两个列表并将它们合并在一起，并输出合并后的列表。

Answer 1

对于

sortedListNode *list1, *list2, *list3;
list3 = list1 + list2;

你需要

sortedListNode *operator+(sortedListNode*lhs, sortedListNode*rhs);

但您只提供

sortedListNode *operator+(sortedListNode lhs, sortedListNode rhs);

我还应该说，为指针类型重载 + 运算符是没有意义的（即使它被允许）。

Answer 2

错误信息的直接原因是您定义的operator+没有被调用。那是因为你定义了你的 operator+ 以两个 sortedListNode 作为参数，但是你传递了两个指针。如果您将运算符更改为采用指针 (sortedListNode*)，它将克服即时语法错误。

然而，这才是真正问题的开始。您对 operator+ 的实施也有问题。它 returns head 不是 sortedListNode 结构的一部分。至关重要的是，它不会使用您传递给它的两个列表中的任何一个。

编辑：现在我们可以看到完整的代码，感谢发布。

我会附和沃尔特所说的：添加指针毫无意义。相反，您应该定义一个 operator+ 来将列表加在一起：

sortedNodeList operator+(const sortedNodeList& lhs, const sortedNodeList &rhs){
  ...
}

换句话说，您的参数应该是对列表的引用（而不是指针），您的结果应该是列表，而不是指针。

重载运算符 +：表达式必须具有整数或无作用域的枚举类型

Overloading operator +: Expression must have integral or unscoped enum type

c++

linked-list

operator-overloading