C++ 重载运算符+；：表达式必须具有整型或非作用域枚举类型

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

我错过了什么

#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] != '\0'; 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);



}

#包括
#包括
使用名称空间std；
结构分类列表节点
{
字符字母；
int=1；
sortedListNode*下一步；
};
sortedListNode*操作员+（sortedListNode*lhs、sortedListNode*rhs）
{
int i=0；
分类列表节点*头、*尾、*当前、*上一个、*模板；
sortedListNode*list1、*list1curr、*list2、*list2curr；
列表1=lhs；
列表2=rhs；
//将列表1复制到输出列表中
head=新的分拣列表节点；
标题->字母=列表1->字母；
头部->出现次数=列表1->出现次数；
head->next=NULL；
尾=头；
list1curr=list1；
list1curr=list1curr->next；
while（list1curr！=NULL）
{
tempLoc=新的sortedListNode；
tempLoc->letter=list1curr->letter；
tempLoc->executions=list1curr->executions；
tempLoc->next=NULL；
tail->next=tempLoc；
tail=tempLoc；
list1curr=list1curr->next；
}
curr=头；
while（list2curr！=NULL）
{
while（curr！=NULL）
{
if（curr->letter==list2curr->letter）
{
curr->occurrents++；
打破
}
如果（（货币->字母->列表2货币->字母）&&（货币==标题））
{
tempLoc=新的sortedListNode；
tempLoc->next=curr；
tempLoc->letter=list2curr->letter；
头部=tempLoc；
打破
}
else if（（curr->letter>list2curr->letter）&（curr！=head））
{
tempLoc=新的sortedListNode；
tempLoc->next=curr；
tempLoc->letter=list2curr->letter；
上一步->下一步=tempLoc；
打破
}
如果（（curr==tail）和&（curr->letterletter））
{
tempLoc=新的sortedListNode；
tempLoc->next=NULL；
tempLoc->letter=list2curr->letter；
tail->next=tempLoc；
tail=tempLoc；
打破
}
上一次=当前；
当前=当前->下一步；
}
curr=头；
list2curr=list2curr->next；
}
回流头；
}
sortedListNode*fromString（字内字符串）
{
int i=0；
分类列表节点*头、*尾、*当前、*上一个、*模板；
//将第一个字母作为第一个元素，设置开头和结尾
//这个元素的尾部。
head=新的分拣列表节点；
尾=头；
标题->字母=inWord[0]；
head->next=NULL；
curr=头；
for（inti=1；inWord[i]！='\0'；i++）
{
while（curr！=NULL）
{
if（curr->letter==inWord[i]）
{
curr->occurrents++；
打破
}
else if（（curr->letter>inWord[i]）&&（curr==head））
{
tempLoc=新的sortedListNode；
tempLoc->next=curr；
tempLoc->letter=inWord[i]；
头部=tempLoc；
打破
}
else if（（curr->letter>inWord[i]）&&（curr！=head））
{
tempLoc=新的sortedListNode；
tempLoc->next=curr；
tempLoc->letter=inWord[i]；
上一步->下一步=tempLoc；
打破
}
如果（（curr==tail）和（&（curr->letternext=NULL；
tempLoc->letter=inWord[i]；
tail->next=tempLoc；
tail=tempLoc；
打破
}
上一次=当前；
当前=当前->下一步；
}
curr=头；
}
回流头；
}
无效打印列表（sortedListNode*inSortedListNode）
{
sortedListNode*curr；
curr=inSortedListNode；
int nodeCounter=0；
while（curr！=NULL）
{
nodeCounter++；
不能

你需要

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

但你只提供

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


我还应该说，为指针类型重载
+
运算符没有任何意义（即使允许）.
错误消息的直接原因是未调用您定义的
运算符+
。这是因为您已将
运算符+
定义为将两个
sortedListNode
作为参数，但您传递了两个指针。如果您将运算符改为使用指针（
sortedListNode*
），它将跳过即时语法错误

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

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

我想附和Walter所说的：添加指针毫无意义。相反，您应该定义一个运算符+来将列表添加到一起：

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

换句话说，您的参数应该是对列表的引用（而不是指针）您的结果应该是一个列表，而不是指针。
我很难确定您试图编译的代码。请发布一个。澄清操作符调用在main中，这就是我得到语法错误的原因。
+
操作符是否应该将这两个列表关联起来（即将它们链接在一起）或者返回一个与输入列表的concatation相等的新列表？您的代码似乎执行后一种操作，但是参数（
lhs
，
rhs
）可能是
const sortedListNode*
。很抱歉，它应该返回一个新列表，这是正确的。a
sortedNodeList operator+(const sortedNodeList& lhs, const sortedNodeList &rhs){
  ...
}