C语言中的分离错误_C_List_Segmentation Fault_Alphabetical

C语言中的分离错误

c list

C语言中的分离错误,c,list,segmentation-fault,alphabetical,C,List,Segmentation Fault,Alphabetical,此程序将按字母顺序从文本创建链接列表。它区分大小写，可以消除标记当我运行程序时，它给出了一个分段错误。我找不到问题出在哪里。为了找到错误，我添加了printf（），但是我找不到 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h> typedef struct NODE { char *word; int count;

此程序将按字母顺序从文本创建链接列表。
它区分大小写，可以消除标记

当我运行程序时，它给出了一个分段错误。我找不到问题出在哪里。为了找到错误，我添加了

printf（）

，但是我找不到

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef struct NODE {
    char *word;
    int count;
    struct NODE *next;
}NODE;

char *get_word(FILE *fp){
     printf("getWord");
     char *str = (char*)malloc(sizeof(char)*100);

     char c;
     do {
        c = fgetc(fp);
        if (c == EOF) 
            return 0;
        } while (!isalpha(c));
        do {
             printf("getWord");

        *str++ = tolower(c);
        c = fgetc(fp);
        printf("Word");

        } while (isalpha(c));

        return str;
        }

void insert(NODE* sortedList, char *word) { 
   printf("INSERT ");

   char *str = (char*)malloc(sizeof(char)*100);
   if (sortedList == NULL || word < sortedList->word) {

      NODE *ekle;
      ekle=(NODE*)malloc(sizeof(NODE));
      strcpy(ekle->word,word);
      ekle->count = 1;
      ekle->next = sortedList;
      sortedList = ekle;
   }
   else {
        // 
      NODE *current = sortedList->next;
      NODE *pre = sortedList;
      while (current != NULL && word > current->word) { 
         pre = current;
         current = current->next;
      }
      if (current != NULL && word == current->word) {

         (current->count)++;
      }
      else {

         NODE *ekle;
         ekle=(NODE*)malloc(sizeof(NODE));
         strcpy(ekle->word,word);
         ekle->count = 1;
         ekle->next = current;
         pre->next = ekle;
      }
   }
}

void createList(FILE* fp,NODE *n) {
   printf("CREATELIST ");
   char *word;
   strcpy(word,get_word(fp));
   puts(word);
   while (strcmp(word,"")) {
      printf("Create_LİST2");
      insert(n,word);
      word = get_word(fp);
   }
}

NODE *head;


int main(){
    NODE *list=NULL;;
    FILE *fp;
    fp=fopen( "text.txt", "r" );
    head=list;

    while(!feof(fp)){

                     createList(fp,list);

                     }
    while(list->next != NULL){
                     printf("%s", list->word);
                     }
    return 0;
}

#包括
#包括
#包括
#包括
类型定义结构节点{
字符*字；
整数计数；
结构节点*下一步；
}节点；
char*get_单词（文件*fp）{
printf（“getWord”）；
char*str=（char*）malloc（sizeof（char）*100）；
字符c；
做{
c=fgetc（fp）；
如果（c==EOF）
返回0；
}而（！isalpha（c））；
做{
printf（“getWord”）；
*str++=tolower（c）；
c=fgetc（fp）；
printf（“Word”）；
}而（isalpha（c））；
返回str；
}
空插入（节点*排序列表，字符*字）{
printf（“插入”）；
char*str=（char*）malloc（sizeof（char）*100）；
if（sortedList==NULL | | wordword）{
节点*ekle；
ekle=（NODE*）malloc（sizeof（NODE））；
strcpy（ekle->word，word）；
ekle->count=1；
ekle->next=分类列表；
分类列表=ekle；
}
否则{
// 
节点*current=sortedList->next；
节点*pre=sortedList；
而（当前！=NULL&&word>current->word）{
pre=电流；
当前=当前->下一步；
}
if（当前！=NULL&&word==current->word）{
（当前->计数）+；
}
否则{
节点*ekle；
ekle=（NODE*）malloc（sizeof（NODE））；
strcpy（ekle->word，word）；
ekle->count=1；
ekle->next=当前；
pre->next=ekle；
}
}
}
void createList（文件*fp，节点*n）{
printf（“创建列表”）；
字符*字；
strcpy（word，get_word（fp））；
放（字）；
while（strcmp（单词“”））{
printf（“创建ST2”）；
插入（n，字）；
单词=获取单词（fp）；
}
}
节点*头；
int main（）{
节点*列表=NULL；；
文件*fp；
fp=fopen（“text.txt”，“r”）；
head=列表；
而（！feof（fp））{
createList（fp，list）；
}
while（列表->下一步！=NULL）{
printf（“%s”，列表->单词）；
}
返回0；
}

一个主要问题是这条线

*str++ = tolower(c);

这会更改指针

str

，因此当您从函数返回

str

时，它实际上会指向字符串之外。顺便说一句，您不能终止的字符串

另一个主要问题是这些线路：

NODE *ekle;
ekle=(NODE*)malloc(sizeof(NODE));
strcpy(ekle->word,word);

这里分配一个

节点

结构，但没有为

ekle->word

分配内存，因此它指向不确定内存。上面的代码有两处

与上述分配问题相同，您有

char *word;
strcpy(word,get_word(fp));

这里也没有为

word

分配内存，因此有一个指向不确定内存的指针

还有，在C中。您还应该注意编译器中的警告，如果您没有从代码中得到任何警告，那么您需要启用更多警告。编译器警告通常是上述所有结果的标志。最后，在编译器旁边，我认为调试器是开发人员最好的工具。学会使用它，它会帮助你解决上面的一些问题。

一个主要问题是这条线

*str++ = tolower(c);

这会更改指针

str

，因此当您从函数返回

str

时，它实际上会指向字符串之外。顺便说一句，您不能终止的字符串

另一个主要问题是这些线路：

NODE *ekle;
ekle=(NODE*)malloc(sizeof(NODE));
strcpy(ekle->word,word);

这里分配一个

节点

结构，但没有为

ekle->word

分配内存，因此它指向不确定内存。上面的代码有两处

与上述分配问题相同，您有

char *word;
strcpy(word,get_word(fp));

这里也没有为

word

分配内存，因此有一个指向不确定内存的指针

这里有一个问题：

char c;
do {
    c = fgetc(fp);
    if (c == EOF) 
        return 0;

这是错误的

fgetc（）

int

，因为

EOF

不适合

char

。因此，第一行应该是：

int c;

这里有一个问题：

char c;
do {
    c = fgetc(fp);
    if (c == EOF) 
        return 0;

这是错误的

fgetc（）

int

，因为

EOF

不适合

char

。因此，第一行应该是：

int c;

不是segfault，而是：您可以使用malloc str，而不使用或释放它

void insert(NODE* sortedList, char *word) { 
  printf("INSERT ");
  char *str = (char*)malloc(sizeof(char)*100);

不是segfault，而是：您可以使用malloc str，而不使用或释放它

void insert(NODE* sortedList, char *word) { 
  printf("INSERT ");
  char *str = (char*)malloc(sizeof(char)*100);

首先，您必须验证文件是否正确打开。然后，如果知道大小限制，strcpy要求目标有足够的空间来存储数据（第74行），而不是“char*word”，例如使用“char-word[255]”。首先，您必须验证文件是否正确打开。然后，假设strcpy要求目的地有足够的空间来存储数据（第74行），而不是“char*word”，例如使用“char-word[255]”（如果您知道大小限制）。

您的主要问题是：

*str++ = tolower(c);

#define MAX_WORD_LEN 101

char* get_word(FILE* fp)
{
    char* str = (char*)malloc(sizeof(char)*MAX_WORD_LEN);
    int c,i;
    do
    {
        c = fgetc(fp);
        if (c == EOF)
        {
            free(str);
            return 0;
        }
    }
    while (!isalpha((char)c));
    i = 0;
    do
    {
        str[i++] = tolower((char)c);
        c = fgetc(fp);
    }
    while (isalpha((char)c) && i < MAX_WORD_LEN-1);
    str[i] = 0;
    return str;
}

首先，一旦您递增

str

，您就不再持有指向动态分配内存的指针。因此，您将无法在以后执行程序时释放该内存，这将最终导致内存泄漏。其次，当您在函数末尾返回

str

时，您是而不是返回您可能希望返回的指向该字符串的指针
其他问题包括：

*str++ = tolower(c);

#define MAX_WORD_LEN 101 char* get_word(FILE* fp) { char* str = (char*)malloc(sizeof(char)*MAX_WORD_LEN); int c,i; do { c = fgetc(fp); if (c == EOF) { free(str); return 0; } } while (!isalpha((char)c)); i = 0; do { str[i++] = tolower((char)c); c = fgetc(fp); } while (isalpha((char)c) && i < MAX_WORD_LEN-1); str[i] = 0; return str; }

您没有确保存储的字符数不超过99个