链表节点数据输出问题

Miracle-s

#include <iostream>
using namespace std;

struct Node
{
       int data;
       Node *next;
};

bool LinkList(Node *L);
void main()
{
        Node *L;
        L=NULL;
        LinkList(L);
        cout<<"hello"<<endl;
        cout<<L->data;
        cout<<L->next;
        free(L);
        L=NULL;
}


bool LinkList(Node *L)
{
        L=(Node *) malloc (sizeof (Node ));
        if(L== NULL)
        {
                cout<<"error"<<endl;
                return false;
        }
        else
        {
                cout<<"ok"<<endl;
                L->data=0;
                L->next=NULL;
                return true;
        }
};


想输出节点的数据和下一节点的地址。

ryxcaixia

1. struct Node
   
2. {
   
3.         int data;
   
4.         Node *next;
   
5. };
   
6. 
   
7. bool LinkList(Node** L);
   
8. void main()
   
9. {
   
10.         Node *L;
    
11.         L=NULL;
    
12.         LinkList(&L);
    
13.         cout<<"hello"<<endl;
    
14.         cout<<L->data;
    
15.         cout<<L->next;
    
16.         free(L);
    
17.         L=NULL;
    
18. }
    
19. 
    
20. 
    
21. bool LinkList(Node** L)
    
22. {
    
23.         *L=(Node *) malloc (sizeof (Node ));
    
24.         if(L== NULL)
    
25.         {
    
26.                 cout<<"error"<<endl;
    
27.                 return false;
    
28.         }
    
29.         else
    
30.         {
    
31.                 cout<<"ok"<<endl;
    
32.                 (*L)->data=0;
    
33.                 (*L)->next=NULL;
    
34.                 return true;
    
35.         }
    
36. };
    

复制代码

楼主, 动态传递内存(如函数内部完成申请, 传递给外面)
要么传递二级指针, 要么传递一级指针的引用
编译器默认会为每个参数拷贝一个形参, 指针也不例外
所以作为副本的临时变量在函数内部确实得到了申请的内存
但是随着函数的结束这个局部变量也就销毁了造成了1. 内存泄露 2. 外面的变量并没有真正的得到申请的内存

Miracle-s

ryxcaixia 发表于 2015-5-28 12:48
楼主, 动态传递内存(如函数内部完成申请, 传递给外面)
要么传递二级指针, 要么传递一级指针的引用
编译 ...

谢谢，又懂了点，:big

ryxcaixia

Miracle-s 发表于 2015-5-28 13:16
谢谢，又懂了点，

给你贴一点东西 亲可以参考下

1. // 形参都是拷贝, 即使指针作为形参也是拷贝一份指针作为副本
   
2. // Swap_1在函数内部完成交换, 出了函数则没有完成交换, 原因就是局部变量销毁, 原指针并没有任何动作
   
3. // Swap_2则完成了交换, 因为操作的是原始数据, 即直接拿着原始的实参进行指向操作
   
4. void Swap_1(int* p1, int* p2)
   
5. {
   
6.         int* temp = p1;
   
7.         p1 = p2;
   
8.         p2 = temp;
   
9. }
   
10. 
    
11. void Swap_2(int** pp1, int** pp2)
    
12. {
    
13.         int* temp = *pp1;
    
14.         *pp1 = *pp2;
    
15.         *pp2 = temp;
    
16. }

复制代码

第一个函数, 达不到交换的效果, 因为函数内部编译器又申请了两个形参, 函数内部完成了交互, 出了函数就死翘翘了
第二个函数, 达到了交换的效果, 因为传递的是二级指针, 对二级指针的一级解引用就相当于那个拿到了真正的外部的那个指针, 从而可以改变指向