关于函数参数的疑惑

[JYYCOM]

今天看了一天数据结构，有点晕。
关于操作链表的函数有些疑问。
假设定义的数据结构为
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode,*LinkList ;
以下几种函数参数形式有什么区别（对链表做了操作）
1> void insert(LinkList &L,int i)
2> void insert(LNode **L,int i)
而下面的（对链表没有进行操作）
3>void GetElem(LinkList L, int i)
请问 A：1，2两个函数参数都是指针的指针，请问两种定义方式有什么区别，或者优缺点。
B: 3能不能定义成 void GetElem(LNode L ,int i)
C: C中调换a b位置的函数swap的两种定义方式有什么区别
void swap(int *a,int *b) 和 void swap(int &a，int &b)

[oyyz1983]

A：1，2两个函数参数都是指针的指针，请问两种定义方式有什么区别?
没什么区别,引用能做到的指针都能做到,只不过有什么时候使用引用就够了.

B: 3能不能定义成 void GetElem(LNode L ,int i)
不可以

[chlaws]

A 这是引用和指针的区别
引用与指针区别
①引用用常量初始化的时候产生一个临时变量
②赋值时,指针不改变所其指向的对象,它改变的只是本身指向
而引用改变的是被引用,本身不改变.这和指针刚好相反
B 最起码也要传递指向链表的指针进去啊,你传值把结点进去有什么用
C 还是A的答案

[珍惜生命远离CPP]

A 传递形式不一样,优缺点不好说,看个人爱好
B 那你去那里得到元素?
C 同A

[JYYCOM]

# define null 0
  typedef struct stacknode{int data;
		struct stacknode *next;}stacklink;
  typedef struct {stacklink *top;int stacksize;}stackk;

  initlink(stackk *s)
  {s->top=(stacklink *)malloc(sizeof(stacklink));
   s->top->data=0;
   s->top->next=null;
  }

  int poplink(stackk *s)
  {stackk *p;int v;
   if(s->top->next==null) printf("the stackis empty\n");
   else {v=s->top->next->data;
   p=s->top->next;
   s->top=s->top->next;
   free(p);
   return v;
  }
    }

  int pushlink(stackk *s,int x)
      {stackk *p;
      p=(stacklink *)malloc(sizeof(stacklink));
      p->data=x;
      p->next=s->top->next;
      s->top->next=p;
	 }

  int gettop(stackk *s)
    {int e;
     if(s==null) printf("the stack is empty!\n");
     e=s->top->next->data;
     return e;
   }
   display(stackk *s)
   {stackk *p;
    p=s->top->next;
    printf("display the stacklink:\n");
    if (s->top=null) printf("the stacklink is empty!\n");
    else {while(p)
	 {printf("->%d",p->data);
	  p=p->next;}
	  }
   }
   main(stacklink *p)
   {int n,k,i,select,h,x1,x2;
    printf("create a empty stacklink!\n");
    initlink(p);
    printf("input a stacklink length:\n");
    scanf("%d",&n);
    for (i=1;i<=n;i++)
   {printf("input a stacklink value:\n");
    scanf("%d",&k);
    pushlink(p,k);
   }
    printf("select 1:display()\n");
    printf("select 2:pushlink()\n");
    printf("select 3:poplink()\n");
    printf("select 4:gettop()\n");
    printf("input a your select(1-4):\n");
    scanf("%d",&select);
    switch(select)
   {case 1:{display(p);break;}
    case 2:{printf("input a push a value :\n");
	    scanf("%d",&h);
	    pushlink(p,h);
	    display(p);
	    break;}
     case 3:{x1=poplink(p);printf("x1->%d\n",x1);
	     display(p);
	     break;}
     case 4: {x2=gettop(p);printf("x2->%d",x2);
	      break;}
	    }
   }

这是一个操作链栈的函数，其中为什么使用的是指针如initlink(stackk *s)，而单链表中操作函数却使用的是指针的指针int length (struct LNode **p)？
对于initlink(stackk *s)，能不能写成 initlink(stackk &s)?

[chlaws]

对于initlink(stackk *s)，能不能写成 initlink(stackk &s)?
可以
对于指针根据实际需要确定其是几级指针

[天空海阔66]

1 void Swap1 (int x, int y) //值传递 实参传给形参时被复制，实参和形参分别占用不同的存储单元。形参不能改变实参.

{
　int temp = x;
　x = y;
　y = temp;
}
2 void Swap2 (int *x, int *y) //引用传递（指针）
{
　int temp = *x; *x = *y;
　*y = temp;
}
3 void Swap3 (int &x, int &y) //引用传递
{
　int temp = x;
　x = y;
　y = temp;
}
　 Swap2使用指针作为参数克服了Swap1的问题，当实参传给形参时，指针本身被复制，而函数中交换的是指针指向的内容。当Swap2返回后，两个实参可以达到交换的目的。
　　Swap3通过使用引用参数克服了Swap1的问题，形参是对应实参的别名，当形参交换以后，实参也就交换了。

1> void insert(LinkList *&L,int i) //引用传递形参的改变影响实参.
2> void insert(LNode **L,int i) //函数调用时的隐含操作是： L=&head,
{
*L=tail;//此时对*L赋值,其实就是对head赋值。
}
void main()
{
insert (&head,3);
}

[JYYCOM]

哎，被引用与指针搞混了。看了基本编程风格不同的数据结构书，糊涂了，主要还是基础不扎实。
有点乱，得捋一捋。
我这么说对不对
引用声明的时候得加 &，如swap(int &a,int &b),但是调用的时候直接用变量名 swap(a,b)
指针声明的时候用* swap(int *a,int * b) ,调用的时候用地址swap (int &a,int &b)
使用引用必须是已经存在实例的情况下才能引用，相当于系统分给的一个受保护的指针，只指向所引用的对象。与指针在使用的时候只是语法规则不同。
操作链表时都得把指针传递给函数，
假设有 typedef struct LNode{
elemtype data;
LNode *next;
}LNode,*Linklist;
如果函数参数为
LNode *p: 则 p->next=...
LNode **p 则 *p->=....
Linklist p 则 p->next=...
Linklist &p 则 *p->next=..

但是还是理解不了，为什么指针能完成的操作，非得用指针的指针来做，在函数里面还得再用'*' 取值。

[chlaws]

哦 是做C的数据结构 你可以先去接触下C++中引用部分的资料
LNode *listnode = new LNode;
LNode *p: 则 p->next= listnode
LNode **p 则 *p->next= listnode
Linklist p 则 p->next=listnode
Linklist &p 则 *p->next=.. //&p 必须先初始化 Linklist &p = listnode; p->next = listnode2;

[malu_1982]

swap(int *, int *)
和swap(int &, int &)
的区别就是传递实参的时候后者比较方便

[青葱岁月不可追]

[Quote=引用 3 楼 akirya 的回复:]

A 传递形式不一样,优缺点不好说,看个人爱好
B 那你去那里得到元素?
C 同A
[/Quote]
up 坏

[JYYCOM]

多谢楼上几位的赐教！