这是一个关于数据结构链表 前插法 的指针内容问题

#include<iostream>
#include<conio.h>
#include<string.h>
#define OK 1
#define MAXSIZE 100
#define ERROR -1
using namespace std;
typedef  int Status;
#define OK 1
typedef  struct  
{
char name[5];
float price;    
}Book;
typedef  Book ElemType;
typedef  struct  LNode 
{
Book data;
LNode *next;

}LNode,*List;

Status InitList(List &L)
{
  L=new LNode();
  /*if(!B)
      exit(-1);
  else
  */
    L->next=NULL;
  return OK;
}
Status GetElem(int i,List L,ElemType &e)
{

List P=L->next; int j=1;
while(P&&j<1)
{


P=P->next;
++j;
}
if(!P||j<i)
return ERROR;
e=P->data;

return OK;
}
Status QianCha(List Head,List L,List  shou)
{
if(Head->next=NULL)
{
    Head->next=L;
    L->next=shou;

}
else
{
   Head->next=L->next;
   L->next=NULL;
}   
   return 0;
}
void Q(LNode * &L,int n)
{
L=new LNode();
L->next=NULL;
cout<<L->next;
for(int i=0;i<n;i++)
{
LNode  *p=new LNode();
cin>>(p->data.price);
p->next=L->next;
L->next=p;
}

}

int main()
{

Book e;
/*
注释代码不用看！
LNode *tou=NULL;

List LL=NULL;
List MM=NULL;
InitList(tou);
List BBB=NULL;
InitList(BBB);
InitList(LL);
InitList(MM);
QianCha(tou,BBB,LL);
QianCha(tou,,BBB);
GetElem(1,tou,e);
*/

LNode * haha;
Q(haha,4);

cout<<e.price;
getch();


return 0;
}

这是我写代码，在调试Q函数（即前插法制造链表）过程中发现

L——>next没有值（我很奇怪，因为L是LNode类型指针，它的next被赋值NULL后应该为0000）
(*L)->next为000000 这个好奇怪，L是指针类型，那么（*L）就是值类型，值类型不能用->写法的，而且最终得0，也非常奇怪

你说得没错啊
(*L)->next 根本就是非法的

根本就不能编译么。至于为什么vc++6.0里面还能搞出 (*L)->next ，这个应该是调试器的bug，调试器没有判断这个表达式是否是非法。但是显然编译器会判断出来。

NULL的值就是0x00000000;就是这个地址。指针是存地址的，你的next是个LNode指针赋予NULL等于指向地址0x00000000没毛病。
L和（*L）值一样，为同一地址。是因为你的这写法 LNode * &L,不知谁教你的。L变成引用指针了
修改L的值实际在修改*haha的值，就是L=new LNode这行实际等于*haha=new LNode。
而L本身是引用指针，所以在L自身->next的地址偏移计算中是没有值的，显示不出来.
L的类型实际为LNode *的引用类型。指针类型实质是值类型，所以可以引用。
*L取值，相等于取*haha值,所以（*L）->next相当于*haha->next所以有被赋予的NULL值0x0000000;

LNode * &L用法错了，L转换成为了指针___*L->next 使用就非法____了_

}LNode,*List;

void Q(LNode * &L,int n)

LNode * haha;
Q(haha,4);

这个写法完全没有问题，Q的作用是初始化数组，引用也就是同一个东西，所以也就是初始化了haha。

其实指针没这么复杂，对于机器指令来讲，就是以某个地址存储的值作为地址，再去寻址此地址的东西，逻辑上多一层跳转。
结构体内部的成员，也就是基地址多个偏移而已。
除了c/c++，其他语言也很少引入指针这种概念。

参数传值，内部修改了，外部看不见修改，其实就是传参数的过程中已经拷贝了一个副本到函数内使用，不然拿函数来干什么，全全局变量好了。
用指针的话，不是修改指针本身，而是用指针的值去寻址，最终读写的都是内存中的同一个地址，所以函数外就看得见修改了。

不用引用，用 LNode ** 二级指针去修改，也是完全ok的

至于调试器提示，应该是版本太旧，新版本VS，gdb都是没问题的
如果一定要纠结，那么正确的写法是：
L->next
(*L).next