0xC0000005: 读取位置 0x00000000 时发生访问冲突

void OutResult(ResultType rslist,int n)
{ int i,j;
  Link p;
  for(i=0;i<n;i++){
    printf("The word ");
    PrintWord(rslist[i].data);
    printf(" appeared in the file %d times",rslist[i].count);
    if(rslist[i].count!=0){
      printf(" and on ");
      p=rslist[i].next;
      for(j=0;j<rslist[i].count;j++)
    {
if(j<rslist[i].count-1)
          { 
    printf("%dth line ",p->elem);
            p=p->next;
           }
else printf("%dth line ",p->elem);
   }
}

这是怎么回事呢？请求各位大神帮助下、、

20 个解决方案

#1

贴完整代码
p是一个指针吧
初步估计你是倒数第5行这个p=p->next出了问题
内存越界了

#2

代码太长，那应该怎么修改呢？

引用楼主 waynezi 的回复:

void OutResult(ResultType rslist,int n)
{ int i,j;
  Link p;
  for(i=0;i<n;i++){
  printf("The word ");
  PrintWord(rslist[i].data);
  printf(" appeared in the file %d times",rslist[i].count);
……

#3

调试一下看看哪一行出的错啊

#4

else printf("%dth line ",p->elem);
这个有问题

引用 2 楼 waynezi 的回复:

代码太长，那应该怎么修改呢？

引用楼主 waynezi 的回复:
void OutResult(ResultType rslist,int n)
{ int i,j;
  Link p;
  for(i=0;i<n;i++){
  printf("The word ");
  PrintWord(rslist[i].data);
  printf(" appeared in t……

#5

完整代码。不然没时间帮你看

#6

下面是我的完整代码
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
#include <math.h>
#define MAXSIZE 1000
#define MAXLEN 20
#define MAXNUM 16
#define FALSE 0
#define TRUE 1
/*---------------堆结构的定义---------------*/
typedef struct{
  char stores[MAXSIZE];
  int freep;              //当前可用空间开始位置
  }HeapSpace;
HeapSpace sp;
/*-------------单词数据类型定义-------------*/
/*-----------单词在堆中的位置描述-----------*/
typedef struct{
  int stadr;        //单词在对空间中的开始位置
  int len;          //单词长度
  }WordType;
/*----------------单词描述-------------------*/
typedef struct{
  char ch[MAXLEN];  //单词字符串
  int size;         //单词长度
  }Sequence;
/*---------------有序表类型定义---------------*/
/*-------------单词有序表结点定义-------------*/
typedef WordType ElemType;
typedef struct NodeType{
  ElemType data;
  struct NodeType *next;
  }NodeType,*LinkType;
/*----------------单词有序表定义--------------*/
typedef struct{
  LinkType head;   //有序表头指针 
  LinkType tail;   //有序表尾指针
  int size;        //有序表结点个数
  }OrderList;
/*---记录一行中匹配成功单词在目标词汇表中的位置---*/
typedef struct{
  int eqelem[MAXNUM];    //单词在目标词汇表中的位置
  int last;              //匹配成功单词的个数
  }EqelemList;

/*-----------文件测试相关的数据类型定义-----------*/
/*--------------单词在文件中的位置----------------*/
typedef struct Node{
   int elem;         //被测单词在文件中的行号
   struct Node *next;//指向下一个行号结点的指针
   }Node,*Link;
/*-----------单词统计分析记录结构定义-------------*/
typedef struct{
   WordType data;   //被测试的单词
   int count;       //在文件中出现的次数
   Link next;       //记录出现的所有行号的脸表头指针
   }HeadNode;
/*---------文本文件测试结果记录定义---------------*/
typedef HeadNode ResultType[MAXNUM];
typedef int status;
/*------------与单词相关的函数----------------*/
/*--------------------------------------------*/
/*             定义新单词函数                 */
/* 功能：把新单词放入堆中                     */
/* 参数：WordType *nw--单词描述信息指针       */
/*       Sequence cha--单词信息               */
/* 返回值：操作成功与否的状态信息             */
/*         0--操作失败，空间不足；1--操作成功 */
/*--------------------------------------------*/
status NewWord(WordType *nw,Sequence cha)
{ int i,k;
  if(sp.freep+cha.size>=MAXSIZE)
    { printf("Heap Full!\n");
      getchar();
      return(0);
      }
  else{
    i=sp.freep;
    sp.freep=sp.freep+cha.size;
    for(k=0;k<cha.size;k++)
      sp.stores[i+k]=cha.ch[k];
    nw->stadr=i;
    nw->len=cha.size;
    return(1);
    }
  }

#7

/*--------------------------------------------*/
/*             复制单词信息函数               */
/* 功能：把一个单词信息复制到另一个变量中     */
/* 参数：WordType *nw--新单词描述信息指针     */ 
/*       WordType oldw--旧单词描述信息指针   */
/* 返回值：无                                 */
/*--------------------------------------------*/
void CopyWord(WordType *nw,WordType oldw)
{ nw->stadr=oldw.stadr;
  nw->len=oldw.len;
  }
/*--------------------------------------------*/
/*             单词比较函数                   */
/* 功能：比较堆中两单词的大小                 */
/* 参数：WordType wd1--第一个单词描述信息     */
/*       WordType wd2--第二个单词描述信息     */
/* 返回值：-1--小于；0--等于；1--大于         */
/*--------------------------------------------*/
int WordCmp(WordType wd1,WordType wd2)
{ int si,sj;
  for(si=wd1.stadr,sj=wd2.stadr;si<(wd1.stadr+wd1.len)&&sj<(wd2.stadr+wd2.len);si++,sj++)
 {
  
   if(sp.stores[si]>sp.stores[sj])
   return (1);
   else if(sp.stores[si]<sp.stores[sj])
      return (-1);
     }
  if(wd1.len>wd2.len)/*两个单词长度不相等*/
  return (1);
  else if(wd1.len<wd2.len)
     return (-1);
       else
   return (0);
  }
/*--------------------------------------------*/
/*             打印单词函数                   */
/* 功能：打印堆中一个单词                     */
/* 参数：WordType wd--单词描述信息            */
/* 返回值：无                                 */
/*--------------------------------------------*/
void PrintWord(WordType wd)
{ int i;
  for(i=0;i<wd.len;i++)
    putchar(sp.stores[wd.stadr+i]);
  }
/*---------------与有序表相关的函数-----------*/
/*--------------------------------------------*/
/*             结点生成函数                   */
/* 功能：生成一个单词在堆中存储信息的结点     */
/* 参数：LinkType *p--生成的新结点指针        */
/*       ElemType e--单词存储信息             */
/* 返回值：TRUE--成功；FALSE--失败            */
/*--------------------------------------------*/
status MakeNode(LinkType *p,ElemType e)
{ *p=(LinkType)malloc(sizeof(NodeType));
  if(!(*p)) return(FALSE);
  (*p)->data.stadr=e.stadr;
  (*p)->data.len=e.len;
  (*p)->next=NULL;
  return(TRUE);
  }
/*--------------------------------------------*/
/*             有序表初始化函数               */
/* 功能：申请头结点，初始化有序表             */
/* 参数：OrderList *L--有序表指针             */
/* 返回值：TRUE--初始化成功；FALSE--初始化失败*/
/*--------------------------------------------*/
status InitList(OrderList *L)
{ ElemType wd;
  wd.stadr=-1;
  wd.len=0;
  if(MakeNode(&(L->head),wd))
   { L->tail=L->head;
     L->head->next=NULL;
     L->size=0;
     return(TRUE);
     }
  else{ L->head=NULL;
return(FALSE);
}
  }
/*--------------------------------------------*/
/*             撤销有序表函数                 */
/* 功能：释放有序表所有结点，撤销有序表       */
/* 参数：OrderList *L--有序表指针             */
/* 返回值：无                                 */
/*--------------------------------------------*/
void DestroyList(OrderList *L)
{ LinkType p,q;
  p=L->head;
  while(p){
    q=p;p=p->next;
    free(q);
    }
  L->head=L->tail=NULL;
  }
/*--------------------------------------------*/
/*             有序表查找函数                 */
/* 功能：确定给定单词e在有序表中的位置        */
/* 参数：OrderList L--有序表                  */
/*       ElemType e--给定要查找的数据e        */
/*       LinkType *q--有序表结点指针          */
/*         查找成功，q指向具有e值的结点       */
/*         查找失败，q指向小于e的结点         */
/* 返回值：int型，1--查找成功；0--查找失败    */
/*--------------------------------------------*/
status LocateElem(OrderList L,ElemType e,LinkType *q)
 { LinkType pre,p;
   int t;
   pre=L.head;
   p=L.head->next;
   while(p)
   {
    t=WordCmp(p->data,e);
    if(t==0)
{
 *q=p;
 return (1);
}
else if(t==-1)
      {
   pre=p;
   p=p->next;
      }
      else
  {
   *q=pre;
   return (0);
  }
   }
   *q=pre;
   return (0);
  }
/*--------------------------------------------*/
/*             有序表插入函数                 */
/* 功能：在指定结点q后插入一个结点s           */
/* 参数：OrderList *L--有序表指针             */
/*       LinkType q--指定结点指针             */
/*       LinkType s--待查入结点指针           */
/* 返回值：无                                 */
/*--------------------------------------------*/
void InsertAfter(OrderList *L,LinkType q,LinkType s)
{ if(L->head&&q&&s){
    s->next=q->next;q->next=s;
    if(L->tail==q) L->tail=s;
    L->size++;
    }
 }
/*------------------------------------------------*/
/*             表匹配函数                         */
/* 功能：把Lb表中匹配La表成功的元素放入s表        */
/* 参数：OrderList La--存放统计单词的有序表       */
/*       OrderList Lb--存放待匹配单词的有序表     */
/*       EqelemList *s--存放匹配成功单词信息表指针*/
/* 返回值：无                                     */
/*------------------------------------------------*/
void ListCompare(OrderList La,OrderList Lb,EqelemList *s)
{ int pos;
  LinkType pa,pb;
  if(La.head&&Lb.head){
    pb=Lb.head->next;
    s->last=0;
pos=0;
    for(pa=La.head->next;pa!=NULL;pa=pa->next)
{
 while(pb)
 {
  if(WordCmp(pa->data,pb->data)==0)
         s->eqelem[s->last++]=pos;
  else if(WordCmp(pa->data,pb->data)==-1)
     break;
  pb=pb->next;
 }//while
 pos++;
 pb=Lb.head->next;
}//for
  }//if
}
/*--------------------------------------------*/
/*             判表空函数                     */
/* 功能：判断表L是否是空表                    */
/* 参数：OrderList L--有序表                  */
/* 返回值：0--非空表；1--空表                 */
/*--------------------------------------------*/
status ListEmpty(OrderList L)
{ if(L.size==0) return(TRUE);
  return(FALSE);
  }
/*-----------与文本文件有关的函数-------------*/
/*--------------------------------------------*/
/*             字符判断函数                   */
/* 功能：判断文件中下一个字符是否为回车符     */
/* 参数：FILE *f--文件指针                    */
/* 返回值：0--不是回车符；1--是回车符         */
/*--------------------------------------------*/
int feoln(FILE *f)
{ char cha;
  cha=fgetc(f);
  ungetc(cha,f);
  if(cha=='\n') return(TRUE);
  return(FALSE);
  }
/*--------------------------------------------*/
/*             读取单词函数                   */
/* 功能：从文件中读取一个单词                 */
/* 参数：FILE *f--文件指针                    */
/*       Sequence *st--指向单词的指针         */
/* 返回值：无                                 */
/*--------------------------------------------*/
 void GetAWord(FILE *f,Sequence *st)
{ char ch;
  st->size=0;
  printf("get a word\n");
  do{
 ch=fgetc(f);
 }while(ch==' ');//do......while
  if(ch=='\n')
  {
   st->size=0;
   return;
  }//if
  while(ch!=' ')
  {
   st->ch[st->size]=ch;
   st->size++;
   ch=fgetc(f);
   if(ch=='\n'||ch==-1)
   {
    ungetc(ch,f);
return;
   }
  }
 }
/*--------------------------------------------*/
/*             读取文件当前行单词函数         */
/* 功能：提取文件指针所在行所有单词           */
/* 参数：FILE *f--文件指针                    */
/*       OrderList *ta--存放单词有序表的指针  */
/* 返回值：0--操作失败；1--操作成功           */
/*--------------------------------------------*/
status ExtractWord(FILE *f,OrderList *ta)
{ 
  Sequence str;
  WordType nwd;
  LinkType p;
  LinkType s;
  printf("Extract word\n");
  if(InitList(ta)==0)
  {
   printf("InitList ta  have errors!!\n");
   return (0);
  }//if
  while(!feof(f)&&!feoln(f))/*文件结束或行结束*/
  {
   GetAWord(f,&str);
   if(str.size==0)
   return (1);
   if(NewWord(&nwd,str)==0)
{
 printf("NewWord errors!\n");
 return (0);
}
   if(MakeNode(&p,nwd)==0)
   {
    printf("MakeNode errors!\n");
return (0);
   }
   LocateElem(*ta,nwd,&s);
   InsertAfter(ta,s,p);
  }//while
  fgetc(f);
  return (1);
}
/*--------------------------------------------*/
/*             文件单词匹配函数               */
/* 功能：统计指定单词在文件中出现的次数和位置 */
/* 参数：FILE *f--文件指针                    */
/*       OrderList pat--指定统计的单词有序表  */
/*       ResultType rs--统计结果列表          */
/* 返回值：0--统计失败；1--统计成功           */
/*--------------------------------------------*/

#8

status match(FILE *f,OrderList pat,ResultType rs)
{ int i,k,linenum,failed,fsp;
  OrderList sa;
  EqelemList eqlist;
  Link q;
  linenum=1;
  while(!feof(f))
  {
  if(InitList(&sa)==0)
  {
   printf("InitList(sa) errors!\n");
   return (0);
  }//if
  eqlist.last=0;
  if(!ExtractWord(f,&sa))
  {
   printf("ExtractWord errors!\n");
   return 0;
  }//if
  ListCompare(pat,sa,&eqlist);
  DestroyList(&sa);
  if(eqlist.last!=0)
  {
   for(i=0;i<eqlist.last;i++)
   {
failed=1;
    fsp=eqlist.eqelem[i];
    rs[fsp].count++;
for(k=0;k<i;k++)
if(eqlist.eqelem[i]==eqlist.eqelem[k])
{failed=0;break;}
if(failed==1)
{
     q=(Link)malloc(sizeof(Node));
 q->elem=linenum;
 q->next=rs[fsp].next;
     rs[fsp].next=q;
}//if语句
   }//for语句
  }//if语句
  linenum++;
  }//while语句
  return (1);
}
/*--------------------------------------------*/
/*             初始化文件函数                 */
/* 功能：输入指定的文件名并打开文件           */
/* 参数：FILE **f--返回的文件指针             */
/* 返回值：0--初始化失败；1--初始化成功       */
/*--------------------------------------------*/
status Initialization(FILE **fr)
{ char FileName[30];
  printf("Input file name:");
  do{ scanf("%s",FileName);
      }while(strlen(FileName)==0);
  *fr=fopen(FileName,"r");
  if(*fr)
   { printf("file open!\n");
     return(TRUE);
     }
  else { printf("file not open!\n");
 return(FALSE);
 }
  }
/*--------------------------------------------*/
/*           输入统计的词集函数               */
/* 功能：输入待统计的词集并建立起数据结构     */
/* 参数：OrderList *pt--返回的词集有序表指针  */
/* 返回值：无                                 */
/*--------------------------------------------*/
void InputWord(OrderList *pt)
{ char cc;
  int t=0;
  Sequence ws;
  LinkType p,q;
  WordType nwd;
  if(!InitList(pt))
  {
   printf("InitList fails!\n");
   return;
  }
  printf("Input the string of words:\n");
  
  while(t==0)
  {
  do{
 cc=getchar();
 }while(cc==' '||cc=='\n');
  ws.size=0;
  while(cc!=' ')
  {
   if(cc=='\n')
   {t=1;break;}
   ws.ch[ws.size]=cc;
   ws.size++;
   cc=getchar();
  }//while
   if(ws.size!=0)
   {
 if(NewWord(&nwd,ws))
 {
  if(MakeNode(&p,nwd))
  {
       LocateElem(*pt,nwd,&q);
   InsertAfter(pt,q,p);
  }//if
 }//if
   }//if
  }//while
 }
/*--------------------------------------------*/
/*           初始化统计结果表函数             */
/* 功能：用待统计词集初始化统计结果表         */
/* 参数：ResultType rs--统计结果数组          */
/*  OrderList pt--待统计的词集表         */
/* 返回值：无                                 */
/*--------------------------------------------*/
void InitRList(ResultType rs,OrderList pat)
 { int k;
   LinkType p;
   p=pat.head->next;
   for(k=0;k<pat.size;k++){
     CopyWord(&rs[k].data,p->data);
     rs[k].next=NULL;
     rs[k].count=0;
     p=p->next;
     }
 }
/*--------------------------------------------*/
/*           输出统计结果函数                 */
/* 功能：输出统计的结果                       */
/* 参数：ResultType rs--统计结果数组          */
/*  int n--待统计的词集个数              */
/* 返回值：无                                 */
/*--------------------------------------------*/
void OutResult(ResultType rslist,int n)
{ int i,j;
  Link p;
  for(i=0;i<n;i++){
    printf("The word ");
    PrintWord(rslist[i].data);
    printf(" appeared in the file %d times",rslist[i].count);
    if(rslist[i].count!=0){
      printf(" and on ");
      p=rslist[i].next;
      for(j=0;j<rslist[i].count;j++)
    {
if(j<rslist[i].count-1)
          { 
    printf("%dth line ",p->elem);
            p=p->next;
           }
else printf("%dth line ",p->elem);
   }
}
  }
 }
/*--------------------------------------------*/
/*         撤销统计结果数据空间函数           */
/* 功能：释放存放统计结果数据的动态存储空间   */
/* 参数：ResultType rs--统计结果数组          */
/* 返回值：无                                 */
/*--------------------------------------------*/
void FreeResult(ResultType rs,int n)
{ int i;
  Link p,q;
  for(i=0;i<n;i++){
    p=rs[i].next;
    while(p){
      q=p;
      p=p->next;
      free(q);
      }
    rs[i].next=NULL;
    rs[i].count=0;
    }
  }
/*--------------------------------------------*/
/*             菜单选择函数                   */
/* 功能：选择要操作内容                       */
/* 参数：无                                   */
/* 返回值：1，2，3，4，5                      */
/*--------------------------------------------*/
int nemu()
{
    int mun;
    printf("\n    ********* Literary research aid *********\n");
    printf("    *%8c1---Input matched words%9c\n",' ','*');
    printf("    *%8c2---Input match file%13c\n",' ','*');
    printf("    *%8c3---Proces file%17c\n",' ','*');
    printf("    *%8c4---Output Result%15c\n",' ','*');
    printf("    *%8c5---Quit%24c\n",' ','*');
    printf("    *****************************************\n");
    printf("%15cSelcet 1,2,3,4,5: ",' ');
    do{
mun=getch()-48;
}while(mun<0 || mun>5);
    printf("\n");
    return(mun);
}
/*--------------------------------------------*/
/*            主函数           */
/*--------------------------------------------*/
void main()
{ int i,flag1=0,flag2=0,flag3=0;
  FILE *fp;
  LinkType pp;
  OrderList pt;
  ResultType rs;
  sp.freep=0;
  pt.size=0;
  for(i=0;i<MAXNUM;i++) rs[i].next=NULL;
  while(1)
    { switch(nemu())
{
    case 1:    //输入待统计的单词集
if(pt.size!=0) DestroyList(&pt);
InputWord(&pt);
pp=pt.head->next;
while(pp)
{
 for(i=pp->data.stadr;i<(pp->data.stadr+pp->data.len);i++)
 putchar(sp.stores[i]);
 printf("\n");
 pp=pp->next;
}
if(!ListEmpty(pt)) flag2=1;
break;
    case 2:   //初始化文件
if(Initialization(&fp)) flag1=1;
break;
    case 3:   //统计分析
if(flag1==0||flag2==0)
 { printf("file not processed!\n");
   getchar();
   break;
   }
 FreeResult(rs,pt.size);
 InitRList(rs,pt);
 if(!match(fp,pt,rs))
 { printf("memory overfllow!\n");
   getchar();
   break;
   }
 else flag3=1;
break;
    case 4:   //输出统计结果
if(flag3==0){
   printf("not result!\n");
   getchar();
   break;
   }
OutResult(rs,pt.size);
break;
    case 5:   //退出系统
FreeResult(rs,pt.size);
DestroyList(&pt);
return;
}
    }
}

#9

楼主你完了 这个我复制一份  哈哈

#10

你复制一份跟我完了有什么关系么？

引用 8 楼 waynezi 的回复:

status match(FILE *f,OrderList pat,ResultType rs)
{ int i,k,linenum,failed,fsp;
  OrderList sa;
  EqelemList eqlist;
  Link q;
  linenum=1;
  while(!feof(f))
  {
  if(InitList(&amp;sa)==0)
  ……

#11

测试你的代码之后，发现2处问题，如下：

一、ResultType是一个含16个元素的数组类型，不是很明白FreeResult第二参数的作用是什么，但是其内用第二参数作循环，n大于16时，数组访问明显越界。

/*--------------------------------------------*/
/* 撤销统计结果数据空间函数 */
/* 功能：释放存放统计结果数据的动态存储空间 */
/* 参数：ResultType rs--统计结果数组 */
/* 返回值：无 */
/*--------------------------------------------*/
void FreeResult(ResultType rs,int n)
{ 
	int i;
	Link p,q;

//n>16时,数组访问越界，我把它上限设成了16，可能不合你的功能
	for(i=0;i<16/*n*/;i++){   
		p=rs[i].next;
		while(p){
			q=p;
			p=p->next;
			free(q);
		}
		rs[i].next=NULL;
		rs[i].count=0;
	}
}

二、DestroyList函数本身并无什么大问题，而且链表释放操作也正确，只是OrderList初始化时其指针成员并未初始化，作为存放在栈上的对象debug下被设置为0xcccccccc，所以OrderList 大小为0时，其head为0xcccccccc不等于0，进入循环，产生拒绝访问错误。

/*--------------------------------------------*/
/* 撤销有序表函数 */
/* 功能：释放有序表所有结点，撤销有序表 */
/* 参数：OrderList *L--有序表指针 */
/* 返回值：无 */
/*--------------------------------------------*/
void DestroyList(OrderList *L)
{ 
	LinkType p,q;
//简单的添加了一个检查，因为我发现你的LinkType所指对象在初始化时都正确的设置了所有字段
//即如果存在一个对象，那么便不会出现访问0xcccccccc的情况。
	if(L->size==0)  
		return;
	p=L->head;
	while(p){
		q=p;p=p->next;
		free(q);
	}
	L->head=L->tail=NULL;
}

#12

单步调试
或者在你认为有错的代码附近下断点调试

#13

地址空间0x00000000到0x0000FFFF是给空指针赋值的。
估计你是访问没有赋值的指针了

#14

这个越界错误，设断点，单步调试

#15

谢谢！我在你说的那两个地方都做了改正，可是问题还没有解决，是不是还有其他问题呢？

引用 10 楼 waynezi 的回复:

你复制一份跟我完了有什么关系么？

引用 8 楼 waynezi 的回复:
status match(FILE *f,OrderList pat,ResultType rs)
{ int i,k,linenum,failed,fsp;
OrderList sa;
EqelemList eqlist;
Link q;
linenum=1;
while(!feof(f))
{
i……

#16

谢谢！我在你说的那两个地方都做了改正，可是问题还没有解决，是不是还有其他问题呢？

引用 11 楼 cranium 的回复:

测试你的代码之后，发现2处问题，如下：

一、ResultType是一个含16个元素的数组类型，不是很明白FreeResult第二参数的作用是什么，但是其内用第二参数作循环，n大于16时，数组访问明显越界。

C/C++ code

/*--------------------------------------------*/
/* 撤销统计结果数据空间函数 */
/* 功能：释……

#17

回楼上：你的问题不是访问冲突么？ 

我对你的代码只更改了那2个地方，之后运行无此错误出现！ 不知为何你同样更改后还是出现该问题？

#18

越界了。。

#19

void OutResult(ResultType rslist,int n)//ResultType rslist,申明的对象！
{ int i,j;
  Link p;  //？？ Link是个指针对象吧？
  for(i=0;i<n;i++){
  printf("The word ");
  PrintWord(rslist[i].data); // rslist[i]数组对象了？
  printf(" appeared in the file %d times",rslist[i].count);
  if(rslist[i].count!=0){
  printf(" and on ");
  p=rslist[i].next; //？？
  for(j=0;j<rslist[i].count;j++)
{
if(j<rslist[i].count-1)
{  
printf("%dth line ",p->elem);
p=p->next;  //？？
}
else printf("%dth line ",p->elem);
}
}

#20

else printf("%dth line ",p->elem);
我把这个删了，就没问题了~

#21

• BUG解析之0xC0000005: 读取位置 0x00000000 时发生访问冲突。