C++ 指针传递问题
我正在尝试实现自己版本的链表以供学习。我有以下代码。reverseList函数工作正常，如果我在该函数中打印它，则效果良好 但是，当我离开函数，然后调用print方法时，我得到第一个值，然后是nothing（null）。我猜当我离开函数时，它会把我带回到最初的第一个（[99]）元素，它现在实际上是最后一个元素。因此，我的print方法输出元素sees null作为下一个元素并结束 或者我认为我在函数中所做的更改只是在该函数的作用域内，即使我传递了一个指针，但这没有意义，因为如果是这样的话，那么我应该保留所有原始数据C++ 指针传递问题,c++,pointers,linked-list,C++,Pointers,Linked List,我正在尝试实现自己版本的链表以供学习。我有以下代码。reverseList函数工作正常，如果我在该函数中打印它，则效果良好 但是，当我离开函数，然后调用print方法时，我得到第一个值，然后是nothing（null）。我猜当我离开函数时，它会把我带回到最初的第一个（[99]）元素，它现在实际上是最后一个元素。因此，我的print方法输出元素sees null作为下一个元素并结束 或者我认为我在函数中所做的更改只是在该函数的作用域内，即使我传递了一个指针，但这没有意义，因为如果是这样的话，那么我
struct ListNode
{
int value;
ListNode* next = NULL;
};
void insertRecList(ListNode* list, int value)
{
if(list->next == NULL)
{
ListNode* end = new ListNode;
end->value = value;
list->next = end;
}
else
insertRecList(list->next, value);
}
void printList(ListNode* list)
{
std::cout << list->value << std::endl;
while(list->next != NULL)
{
list = list->next;
std::cout << list->value << std::endl;
}
}
void reverseList(ListNode* list)
{
ListNode* next;
ListNode* prev = NULL;
ListNode* cur = list;
while(cur != NULL)
{
if(cur->next == NULL)
{
cur->next = prev;
break;
}
else
{
next = cur->next;
cur->next = prev;
prev = cur;
cur = next;
}
}
list = cur;
std::cout << cur->value << " list:" << list->value << std::endl;
}
void testLinkedList()
{
srand(time(NULL));
ListNode nodes;
nodes.value = 99;
int val;
for(int i = 0; i < 5; i++)
{
val = rand() % 30 + 1;
insertRecList(&nodes, i);
//insertList(&nodes, val);
}
printList(&nodes);
reverseList(&nodes);
printList(&nodes);
}
int main()
{
testLinkedList();
return 0;
}
struct ListNode
{
int值；
ListNode*next=NULL；
};
void insertRecList（列表节点*列表，int值）
{
如果（列表->下一步==NULL）
{
ListNode*end=新的ListNode；
结束->值=值；
列表->下一步=结束；
}
其他的
insertRecList（列表->下一步，值）；
}
作废打印列表（列表节点*列表）
{
std:：cout value next！=NULL）
{
列表=列表->下一步；
std:：cout value next==NULL）
{
cur->next=prev；
打破
}
其他的
{
下一步=当前->下一步；
cur->next=prev；
prev=cur；
cur=下一个；
}
}
列表=cur；
标准：：cout值更新：
通过将ListNode*list
传递给reverseList
，您可以创建指向与节点
相同地址的指针副本。在函数内部，您可以将list
分配给更新后的cur
指针，但副本将在最后销毁。list
仍然指向与之相同的地址在传递到reverseList
之前，但其next
已更改
我对您的代码做了一些修改：
#include <cstdlib>
#include <iostream>
struct ListNode
{
int value;
ListNode* next = nullptr;
};
void insertRecList(ListNode* list, int value)
{
if(list->next == nullptr)
{
ListNode* end = new ListNode;
end->value = value;
list->next = end;
}
else
insertRecList(list->next, value);
}
void printList(ListNode* list)
{
std::cout << list->value << std::endl;
while(list->next != nullptr)
{
list = list->next;
std::cout << list->value << std::endl;
}
}
void reverseList(ListNode** list)
{
ListNode* cur = *list;
ListNode* next = cur->next;
ListNode* prev = nullptr;
while(cur != nullptr)
{
next = cur->next;
cur->next = prev;
prev = cur;
cur = next;
}
*list = prev;
}
void cleanNodes(ListNode *list) {
// clean goes here
}
void testLinkedList()
{
srand(time(nullptr));
ListNode *nodes = new ListNode();
nodes->value = 99;
int val;
for(int i = 0; i < 5; i++)
{
val = rand() % 30 + 1;
insertRecList(nodes, i);
//insertList(&nodes, val);
}
printList(nodes);
reverseList(&nodes);
printList(nodes);
cleanNodes(nodes);
}
int main()
{
testLinkedList();
return 0;
}
#包括
#包括
结构列表节点
{
int值；
ListNode*next=nullptr；
};
void insertRecList（列表节点*列表，int值）
{
如果（列表->下一步==nullptr）
{
ListNode*end=新的ListNode；
结束->值=值；
列表->下一步=结束；
}
其他的
insertRecList（列表->下一步，值）；
}
作废打印列表（列表节点*列表）
{
std:：cout value next！=nullptr）
{
列表=列表->下一步；
std：：下一个cout值；
ListNode*prev=nullptr；
while（cur！=nullptr）
{
下一步=当前->下一步；
cur->next=prev；
prev=cur；
cur=下一个；
}
*列表=上一个；
}
void cleanNodes（列表节点*列表）{
//这里是干净的
}
void testLinkedList（）
{
srand（时间（nullptr））；
ListNode*节点=新建ListNode（）；
节点->值=99；
int-val；
对于（int i=0；i<5；i++）
{
val=rand（）%30+1；
insertRecList（节点，i）；
//插入列表（&节点，val）；
}
打印列表（节点）；
反向列表（&节点）；
打印列表（节点）；
清洁节点（节点）；
}
int main（）
{
testLinkedList（）；
返回0；
}
尝试使用：-std=gnu++11编译，反转链表不是一个基本操作。它不属于类的基本操作。在其他操作中实现它更容易（更安全）。大致如下：
- 创建一个空列表
- 当第一个列表不为空时，从第一个列表的前面删除一个节点，然后将其插入第二个列表的前面
第二个列表现在与原始列表相反。在reverseList
中，您没有更改节点
，您只是更改列表
您的结构上的一个指针，它是一个临时对象，因此节点在物理上是相同的，并指向现在具有next
attrib的相同的第一个元素ute指向Null
，因此printList
的结果是正确的
#include <iostream>
#include <cstdlib>
struct ListNode
{
int value;
ListNode* next = NULL;
~ListNode(){
if(this->next)
delete this->next;
}
};
void insertRecList(ListNode* list, int value)
{
if(list->next == NULL)
{
ListNode* end = new ListNode;
end->value = value;
list->next = end;
}
else
insertRecList(list->next, value);
}
void printList(ListNode* list)
{
std::cout << list->value << std::endl;
while(list->next != NULL)
{
list = list->next;
std::cout << list->value << std::endl;
}
}
ListNode * reverseList(ListNode* list)
{
ListNode* next;
ListNode* prev = NULL;
ListNode* cur = list;
while(cur != NULL)
{
if(cur->next == NULL)
{
cur->next = prev;
break;
}
else
{
next = cur->next;
cur->next = prev;
prev = cur;
cur = next;
}
}
std::cout << cur->value << " list:" << list->value << std::endl;
return cur;
}
void testLinkedList()
{
srand(time(NULL));
ListNode * nodes = new ListNode;
nodes->value = 99;
int val;
for(int i = 0; i < 5; i++)
{
val = rand() % 30 + 1;
insertRecList(nodes, i);
//insertList(&nodes, val);
}
printList(nodes);
nodes = reverseList(nodes);
printList(nodes);
delete nodes;
}
int main()
{
testLinkedList();
return 0;
}
#包括
#包括
结构列表节点
{
int值；
ListNode*next=NULL；
~ListNode（）{
如果（本->下一步）
删除此->下一步；
}
};
void insertRecList（列表节点*列表，int值）
{
如果（列表->下一步==NULL）
{
ListNode*end=新的ListNode；
结束->值=值；
列表->下一步=结束；
}
其他的
insertRecList（列表->下一步，值）；
}
作废打印列表（列表节点*列表）
{
std:：cout value next！=NULL）
{
列表=列表->下一步；
std:：cout value next==NULL）
{
cur->next=prev；
打破
}
其他的
{
下一步=当前->下一步；
cur->next=prev；
prev=cur；
cur=下一个；
}
}
std:：cout value在insertRecList
中的prev
指针在哪里寻址？我没有，prev指针仅用于反转。这是一个单链接列表，而不是双链接列表。建议：在必须使用随机数进行测试之前，不使用随机数进行测试。一致性是调试的关键之一。您点击sam反复重复，直到你发现模式并修复它。随机数使发现模式变得越来越困难。@CodySavage-gotcha，刚刚看到插入和prev
，有点困惑…我道歉，但我不明白，也许我误解了，但你是说我的循环提前终止了吗？如果是，我不这么认为，我可以打印该函数中的列表，它是正确的。我正在设置下一个节点，然后再更改cur节点，这样它将继续正常运行。即：在每次迭代开始时，下一个节点是实际的下一个节点，而不是上一个。就是这样，我非常感谢您的帮助。