C++ C++；错误C2819:类型'；列表'；没有重载成员'；操作员->'；

我一直在犯这个错误-

错误C2819:类型“列表”没有 重载的成员“运算符->”

我不明白为什么？帮忙

Main.cpp-

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

#include "List.h"
#include "Node.h"

#include <iostream>
#include <string>
#include <cassert>
#include "Node.h"
#include "List.h"
using namespace std;

Node * List:: get ( int position_of_node ) {
 assert ( First != NULL);
 Node * temp = First;
 for (int i = 1; i < position_of_node; i++) 
  { temp = temp->getNext(); }
 return temp;
}

int List:: search_item_list (string item_searching_for ) {
 assert (First != NULL && num_in_list != 0);
 int counter = 1;
 Node * temp = First;
 while ( temp->getItemName() != item_searching_for || temp->getNext() == NULL )
  { temp = temp->getNext(); counter++; }
 return counter;
}

void List:: add (Node * node_to_be_added) {
 if (num_in_list == 0) { First = node_to_be_added; Last = node_to_be_added; }
 else if (num_in_list != 0 ) {
  Last->setNext(node_to_be_added);
  node_to_be_added->setPrevous(Last);
  Last = node_to_be_added;
 }
 num_in_list++;
}

Node * List :: pop_back ( ) {
 assert (Last != NULL);
 if ( num_in_list > 1) {
  Node * temp = Last;
  Last = Last->getPrevous();
  Last->setNext(NULL);
  temp->setNext(NULL);
  temp->setPrevous(NULL);
  return temp;
 }
 else if ( num_in_list == 1 ) {
  Node * temp = First;
  First = NULL;
  return temp;
 }
 else return NULL;
}

Node * List:: pop_front ( ) {
 assert ( First != NULL && num_in_list > 0);
 if ( num_in_list > 1 ) {
  Node * temp = First;
  First = First->getNext();
  First->setPrevous(NULL);
  temp->setNext(NULL);
  temp->setPrevous(NULL);
  return temp;
 }

 else if ( num_in_list == 1) {
  Node * temp = First;
  First = NULL;
  return temp;
 }
 else return NULL;
}

void List:: del_last ( ) {
 assert ( Last != NULL );
 if ( num_in_list > 1) {
  Node * temp_node = Last->getPrevous();
  Node * new_last = Last;
  temp_node->setNext(NULL);
  delete new_last;
  num_in_list--;
 }
 else if ( num_in_list == 1) {
  Node * temp = First;
  delete temp;
  num_in_list = 0;
  First = NULL;
 }
}

void List:: del_frnt ( ) {
 assert ( First != NULL);
 if ( num_in_list > 1) {
  Node * saveFirst = First;
  First->getNext()->setPrevous(NULL);
     First = First->getNext( );
     delete saveFirst;
     num_in_list--;
 }
 else if ( num_in_list == 1 ) {
  Node * saveFirst = First;
  delete saveFirst;
  num_in_list = 0;
  First = NULL;
 }
}

void List:: push_back (Node * new_node) {
 assert ( Last != NULL );
 Last->setNext(new_node);
 new_node->setPrevous(Last);
 Last = new_node;
 num_in_list++;
}

void List:: push_front (Node * new_node) {
 if ( First != NULL) {
  First->setPrevous(new_node);
  new_node->setPrevous(NULL);
  new_node->setNext(First);
  First = new_node;
  num_in_list++;
 }
 else if ( First == NULL ) {
  First = new_node;
  Last = new_node;
  num_in_list = 1;
 }
}

#ifndef NODE_H
#define NODE_H
#include <string>
using namespace std;

class Node 
{
private:
 string ItemName;
 string Quantity;
 Node * Next;
 Node * Prevous;
public:
 Node () { ItemName = " "; Quantity = " "; }
 void setItemName (string a) { ItemName = a; }
 string getItemName () { return ItemName; }
 void setQuantity (string a) { Quantity = a; }
 string getQuantity () { return Quantity; }
 void setNext (Node * a) { *Next = *a; }
 Node * getNext () { return Next; }
 void setPrevous (Node * a) { *Prevous = *a; }
 Node * getPrevous () { return Prevous; }
};
#endif

列表.cpp-

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

#include "List.h"
#include "Node.h"

#include <iostream>
#include <string>
#include <cassert>
#include "Node.h"
#include "List.h"
using namespace std;

Node * List:: get ( int position_of_node ) {
 assert ( First != NULL);
 Node * temp = First;
 for (int i = 1; i < position_of_node; i++) 
  { temp = temp->getNext(); }
 return temp;
}

int List:: search_item_list (string item_searching_for ) {
 assert (First != NULL && num_in_list != 0);
 int counter = 1;
 Node * temp = First;
 while ( temp->getItemName() != item_searching_for || temp->getNext() == NULL )
  { temp = temp->getNext(); counter++; }
 return counter;
}

void List:: add (Node * node_to_be_added) {
 if (num_in_list == 0) { First = node_to_be_added; Last = node_to_be_added; }
 else if (num_in_list != 0 ) {
  Last->setNext(node_to_be_added);
  node_to_be_added->setPrevous(Last);
  Last = node_to_be_added;
 }
 num_in_list++;
}

Node * List :: pop_back ( ) {
 assert (Last != NULL);
 if ( num_in_list > 1) {
  Node * temp = Last;
  Last = Last->getPrevous();
  Last->setNext(NULL);
  temp->setNext(NULL);
  temp->setPrevous(NULL);
  return temp;
 }
 else if ( num_in_list == 1 ) {
  Node * temp = First;
  First = NULL;
  return temp;
 }
 else return NULL;
}

Node * List:: pop_front ( ) {
 assert ( First != NULL && num_in_list > 0);
 if ( num_in_list > 1 ) {
  Node * temp = First;
  First = First->getNext();
  First->setPrevous(NULL);
  temp->setNext(NULL);
  temp->setPrevous(NULL);
  return temp;
 }

 else if ( num_in_list == 1) {
  Node * temp = First;
  First = NULL;
  return temp;
 }
 else return NULL;
}

void List:: del_last ( ) {
 assert ( Last != NULL );
 if ( num_in_list > 1) {
  Node * temp_node = Last->getPrevous();
  Node * new_last = Last;
  temp_node->setNext(NULL);
  delete new_last;
  num_in_list--;
 }
 else if ( num_in_list == 1) {
  Node * temp = First;
  delete temp;
  num_in_list = 0;
  First = NULL;
 }
}

void List:: del_frnt ( ) {
 assert ( First != NULL);
 if ( num_in_list > 1) {
  Node * saveFirst = First;
  First->getNext()->setPrevous(NULL);
     First = First->getNext( );
     delete saveFirst;
     num_in_list--;
 }
 else if ( num_in_list == 1 ) {
  Node * saveFirst = First;
  delete saveFirst;
  num_in_list = 0;
  First = NULL;
 }
}

void List:: push_back (Node * new_node) {
 assert ( Last != NULL );
 Last->setNext(new_node);
 new_node->setPrevous(Last);
 Last = new_node;
 num_in_list++;
}

void List:: push_front (Node * new_node) {
 if ( First != NULL) {
  First->setPrevous(new_node);
  new_node->setPrevous(NULL);
  new_node->setNext(First);
  First = new_node;
  num_in_list++;
 }
 else if ( First == NULL ) {
  First = new_node;
  Last = new_node;
  num_in_list = 1;
 }
}

#ifndef NODE_H
#define NODE_H
#include <string>
using namespace std;

class Node 
{
private:
 string ItemName;
 string Quantity;
 Node * Next;
 Node * Prevous;
public:
 Node () { ItemName = " "; Quantity = " "; }
 void setItemName (string a) { ItemName = a; }
 string getItemName () { return ItemName; }
 void setQuantity (string a) { Quantity = a; }
 string getQuantity () { return Quantity; }
 void setNext (Node * a) { *Next = *a; }
 Node * getNext () { return Next; }
 void setPrevous (Node * a) { *Prevous = *a; }
 Node * getPrevous () { return Prevous; }
};
#endif

#包括
#包括
#包括
#包括“Node.h”
#包括“List.h”
使用名称空间std；
节点*列表：：获取（节点的int位置）{
断言（第一个！=NULL）；
节点*温度=第一；
for（int i=1；i<节点的位置；i++）
{temp=temp->getNext（）；}
返回温度；
}
int List：：搜索项目列表（字符串项目搜索）{
断言（第一个！=NULL&&num\u在\u列表中！=0）；
int计数器=1；
节点*温度=第一；
while（temp->getItemName（）！=item|u搜索| | temp->getNext（）==NULL）
{temp=temp->getNext（）；计数器++；}
返回计数器；
}
无效列表：：添加（节点*要添加的节点）{
如果（num_in_list==0）{First=node_to_be_added；Last=node_to_be_added；}
else if（列表中的num\u！=0）{
Last->setNext（要添加的节点）；
要添加的节点->设置前一个（最后一个）；
Last=要添加的节点；
}
num_in_list++；
}
节点*列表：：弹出返回（）{
断言（Last！=NULL）；
如果（列表中的数值>1）{
节点*temp=Last；
Last=Last->getPrevous（）；
最后->设置下一步（空）；
temp->setNext（空）；
temp->setPrevous（空）；
返回温度；
}
else if（列表中的num\u==1）{
节点*温度=第一；
第一个=空；
返回温度；
}
否则返回NULL；
}
节点*列表：：pop_front（）{
断言（第一个！=NULL&&num\u，在\u列表中>0）；
如果（列表中的数值>1）{
节点*温度=第一；
First=First->getNext（）；
第一个->设置前一个（空）；
temp->setNext（空）；
temp->setPrevous（空）；
返回温度；
}
else if（列表中的num\u==1）{
节点*温度=第一；
第一个=空；
返回温度；
}
否则返回NULL；
}
无效列表：：del_last（）{
断言（Last！=NULL）；
如果（列表中的数值>1）{
节点*temp_Node=Last->getPrevous（）；
节点*new_last=last；
临时节点->设置下一步（空）；
最后删除新的_；
列表中的num_--；
}
else if（列表中的num\u==1）{
节点*温度=第一；
删除临时文件；
_列表中的num_=0；
第一个=空；
}
}
无效列表：：del_frnt（）{
断言（第一个！=NULL）；
如果（列表中的数值>1）{
节点*saveFirst=First；
First->getNext（）->setPrevous（NULL）；
First=First->getNext（）；
先删除saveFirst；
列表中的num_--；
}
else if（列表中的num\u==1）{
节点*saveFirst=First；
先删除saveFirst；
_列表中的num_=0；
第一个=空；
}
}
无效列表：：推回（节点*新节点）{
断言（Last！=NULL）；
最后->设置下一步（新建_节点）；
新建节点->设置前一个（最后一个）；
Last=新的_节点；
num_in_list++；
}
无效列表：：向前推（节点*新节点）{
如果（第一个！=NULL）{
第一个->设置前一个（新节点）；
新建_节点->设置前置（空）；
新建节点->设置下一步（第一步）；
第一个=新的_节点；
num_in_list++；
}
else if（First==NULL）{
第一个=新的_节点；
Last=新的_节点；
_列表中的num_=1；
}
}

节点.h-

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

#include "List.h"
#include "Node.h"

#include <iostream>
#include <string>
#include <cassert>
#include "Node.h"
#include "List.h"
using namespace std;

Node * List:: get ( int position_of_node ) {
 assert ( First != NULL);
 Node * temp = First;
 for (int i = 1; i < position_of_node; i++) 
  { temp = temp->getNext(); }
 return temp;
}

int List:: search_item_list (string item_searching_for ) {
 assert (First != NULL && num_in_list != 0);
 int counter = 1;
 Node * temp = First;
 while ( temp->getItemName() != item_searching_for || temp->getNext() == NULL )
  { temp = temp->getNext(); counter++; }
 return counter;
}

void List:: add (Node * node_to_be_added) {
 if (num_in_list == 0) { First = node_to_be_added; Last = node_to_be_added; }
 else if (num_in_list != 0 ) {
  Last->setNext(node_to_be_added);
  node_to_be_added->setPrevous(Last);
  Last = node_to_be_added;
 }
 num_in_list++;
}

Node * List :: pop_back ( ) {
 assert (Last != NULL);
 if ( num_in_list > 1) {
  Node * temp = Last;
  Last = Last->getPrevous();
  Last->setNext(NULL);
  temp->setNext(NULL);
  temp->setPrevous(NULL);
  return temp;
 }
 else if ( num_in_list == 1 ) {
  Node * temp = First;
  First = NULL;
  return temp;
 }
 else return NULL;
}

Node * List:: pop_front ( ) {
 assert ( First != NULL && num_in_list > 0);
 if ( num_in_list > 1 ) {
  Node * temp = First;
  First = First->getNext();
  First->setPrevous(NULL);
  temp->setNext(NULL);
  temp->setPrevous(NULL);
  return temp;
 }

 else if ( num_in_list == 1) {
  Node * temp = First;
  First = NULL;
  return temp;
 }
 else return NULL;
}

void List:: del_last ( ) {
 assert ( Last != NULL );
 if ( num_in_list > 1) {
  Node * temp_node = Last->getPrevous();
  Node * new_last = Last;
  temp_node->setNext(NULL);
  delete new_last;
  num_in_list--;
 }
 else if ( num_in_list == 1) {
  Node * temp = First;
  delete temp;
  num_in_list = 0;
  First = NULL;
 }
}

void List:: del_frnt ( ) {
 assert ( First != NULL);
 if ( num_in_list > 1) {
  Node * saveFirst = First;
  First->getNext()->setPrevous(NULL);
     First = First->getNext( );
     delete saveFirst;
     num_in_list--;
 }
 else if ( num_in_list == 1 ) {
  Node * saveFirst = First;
  delete saveFirst;
  num_in_list = 0;
  First = NULL;
 }
}

void List:: push_back (Node * new_node) {
 assert ( Last != NULL );
 Last->setNext(new_node);
 new_node->setPrevous(Last);
 Last = new_node;
 num_in_list++;
}

void List:: push_front (Node * new_node) {
 if ( First != NULL) {
  First->setPrevous(new_node);
  new_node->setPrevous(NULL);
  new_node->setNext(First);
  First = new_node;
  num_in_list++;
 }
 else if ( First == NULL ) {
  First = new_node;
  Last = new_node;
  num_in_list = 1;
 }
}

#ifndef NODE_H
#define NODE_H
#include <string>
using namespace std;

class Node 
{
private:
 string ItemName;
 string Quantity;
 Node * Next;
 Node * Prevous;
public:
 Node () { ItemName = " "; Quantity = " "; }
 void setItemName (string a) { ItemName = a; }
 string getItemName () { return ItemName; }
 void setQuantity (string a) { Quantity = a; }
 string getQuantity () { return Quantity; }
 void setNext (Node * a) { *Next = *a; }
 Node * getNext () { return Next; }
 void setPrevous (Node * a) { *Prevous = *a; }
 Node * getPrevous () { return Prevous; }
};
#endif

\ifndef节点
#定义节点
#包括
使用名称空间std；
类节点
{
私人：
字符串ItemName；
串数；
节点*下一步；
前淋巴结；
公众：
节点（）{ItemName=”“；Quantity=”“；}
void setItemName（字符串a）{ItemName=a；}
字符串getItemName（）{return ItemName；}
void setQuantity（字符串a）{Quantity=a；}
字符串getQuantity（）{返回数量；}
void setNext（Node*a）{*Next=*a；}
Node*getNext（）{return Next；}
void setPrevous（Node*a）{*Prevous=*a；}
Node*getPrevous（）{return Prevous；}
};
#恩迪夫

注意：我知道我正在做的只是一个列表，但对于一个拼贴类，我必须这样做：） -任何帮助/指点/如何做得更好都将很棒

不能同时执行以下两个操作：

Node * temp = list.getFirst();
Node * temp2 = list->getLast();

前者可以工作，因为您正在按值传递

列表

，但要使后者工作，您需要重载

运算符->

。只需使用：

Node * temp2 = list.getLast();

注意：在C++中，访问聚合成员（数据成员或函数）的语法是：

及

（好的，我简化了一点，但这应该可以帮助您入门。）

列表不是中的指针

---

节点*temp2=list->getLast（）

更改

节点*temp2=list->getLast（）到
节点*temp2=list.getLast（）
会让它工作，但我认为这不是最好的解决方案。您正在通过值将列表传递到
PrintList（）
，这将调用复制构造函数。更好的方法是将
const
引用传递给列表。您仍然需要将
->
更改为
。
在PrintList函数中，您有一个类型为List的参数：

void PrintList ( List list )
作废打印列表（列表）
当您尝试使用list.getFirst（）访问它时，一切正常。当您尝试执行list->getLast（）时，编译器会生成一个错误，告诉您变量不是指针类型。在short PrintList函数中，您可能希望将所有->替换为。操作人员如果要使用->，必须执行以下操作：

List * listptr = new List();
listptr->getFirst();
listptr->getLast();
List*listptr=newlist（）；
listptr->getFirst（）；
listptr->getLast（）；
否则，只需将第二行替换为：Node*temp2=list.getLast（）

您可以创建一个自定义->操作符，但我认为这不是您真正想要做的

另外，我没有仔细研究它，但是您的while循环是否会终止？除非对getItemName的调用将改变节点的值，否则这种情况看起来可能会永远持续下去。
注意这一点

*节点*temp2=list->getLast（）*

列表应该是一个对象，而不是一个指针，因此您不应该使用“->”，而应该使用“.”
只有当您的变量是指针时才使用->语法，否则就使用它。请注意，最好给出一个最小的可编译示例来重现问题，然后将所有代码扔给我们。你也不会知道解决方案就发生在你身上