动态增长的字符串阵列内存问题

Question

我正在制作填字游戏程序，其中必须使用单词字典。我正在尝试将jspell字典文件加载到动态字符串阵列中，但我一直在得到

错误malloc（）：不匹配下一步

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

#include "dictionary.h"


void dict_init(Dictionary * dict, char * dict_dir, size_t w_len)
{

    printf("dictionary.c (dict_init): initializing dictionary.\n");

    /*Adjust this value to control the initial array size*/
    size_t init_size = 1000;

    /*initialize dictionary file directory*/
    dict->dir = malloc(strlen(dict_dir) * sizeof(char) + 1);
    strcpy(dict->dir, dict_dir);

    /*create memory for words array*/
    dict->words = malloc(init_size * sizeof(char *));

    /*initialize array size*/
    dict->size = init_size;

    /*initilize word length*/
    dict->w_len = w_len;

    /*initialize word counter*/
    dict->counter = 0;

    /*load words into dictionary*/
    dict_load(dict);

    printf("dictionary.c (dict_init): dictionary initialized.\n");
}


void dict_add(Dictionary * dict, char * word)
{
    char ** dictionary = dict->words;

    /*check if word array is full*/
    if(dict->counter == dict->size)
    {
        /*increrase size of dictionary*/
        dict->size *= 1.5;
        dict->words = realloc(dict->words, dict->size * sizeof(char *));
    }

    /*add word to dictionary*/
    dictionary[dict->counter] = malloc(strlen(word) * sizeof(char) + 1);
    strcpy(dictionary[dict->counter], word);
    dict->counter++;

    free(word);
}


void dict_free(Dictionary * dict) 
{
    free(dict->words);
}


void dict_load(Dictionary * dict)
{
    FILE * fp;

    char * line = NULL;
    char * word = NULL;

    size_t len = 0;
    ssize_t read;

    fp = fopen(dict->dir, "r");

    /*check if file exists*/
    if (fp == NULL)
    {
        perror("ERROR: File not found.");
        exit(EXIT_FAILURE);
    }

    /*discard first line*/
    if(strstr(dict->dir, ".dic"))
        getline(&line, &len, fp);

    /*read file lines*/
    while ((read = getline(&line, &len, fp)) != -1) 
    {
        if(((strstr(line, "[CAT=punct") == NULL) && (word = parse_line(line, dict->w_len)) != NULL)) {
            dict_add(dict, word);
        }
    }

    fclose(fp);
    free(line);

    printf("dictionary.c (dict_load): dictionary loaded %ld words.\n", dict->counter);
}


char * parse_line(char * line, size_t w_len)
{
    int i;
    char s_tmp[101] = "";
    char * dlm_slash, * dlm_space, * dlm_tab , *substring;

    /*get delimiter pointer*/
    dlm_slash = strchr(line, '/');
    dlm_space = strchr(line, ' ');
    dlm_tab = strchr(line, '\t');

    /*check if delimiter exists in line*/
    if(dlm_slash != NULL)
        i = (int)(dlm_slash - line);

    else if(dlm_space != NULL)
        i = (int)(dlm_space - line);

    else if(dlm_tab != NULL)
        i = (int)(dlm_tab - line);

    else
    {
        /*replace '\n' with '\0'*/
        line[strcspn(line, "\n")] = '\0';
    
        i = strlen(line);
    }

    strncpy(s_tmp, line, i);

    substring = malloc(sizeof(char) * strlen(s_tmp) + 1);
    strncpy(substring, s_tmp, strlen(s_tmp));

    /*lowercase word*/
    lower_case(substring);

    if((is_valid(substring) == 0) && (strlen(substring) <= w_len))
        return substring;

    free(substring);
    return NULL;
}

Answer 1

我认为这是基本问题：

void dict_add(Dictionary * dict, char * word) {
char ** dictionary = dict->words;       /* **** 1 **** */

/*check if word array is full*/
if(dict->counter == dict->size)
{
    /*increrase size of dictionary*/
    dict->size *= 1.5;                  /* **** 2 **** */
    dict->words = realloc(dict->words, dict->size * sizeof(char *));
                                        /* **** 3 **** */
}

/*add word to dictionary*/

这是一个问题：

dictionary[dict->counter] = malloc(strlen(word) * sizeof(char) + 1);
strcpy(dictionary[dict->counter], word);
dict->counter++;

free(word);                            /* **** 4 **** */
}

问题是dictionary在您称为之前保存了 realloc。 realloc可能会进行全新的内存分配，在这种情况下，它将自动free（）将其内容复制到新的内容后。因此，您在调用realloc之前制作的指针的任何副本都可能最终指向未分配的内存。写信给未分配的记忆是一个很大的禁忌。在这种特殊情况下，您可能会覆盖Malloc的簿记信息有关未分配的块的信息，这就是为什么它检测到问题并抱怨的原因。算上自己幸运的是：许多内存腐败问题都在相当长的一段时间内没有发现，直到工厂爆炸。

我在编写此书时注意到的其他一些问题，源中有编号的注释：

1. 实际上根本不需要变量dictionary。

2. dict-＆gt; size是一个整数。强迫转换为浮点数，然后将其截断回整数不是很有用。优先dict-＆gt; size += dict-＆gt; size/2;。最好是首先确保dict-＆gt; size并不那么大，以至于增加它会导致整数环绕。 （这不是size_t之类的未签名类型的不确定行为，但不会产生正确的结果。）

3. 您实际上可以使用临时性，因为realloc可能会使用返回null指示内存分配失败。如果发生这种情况，原始分配是不是自动释放的，您没有办法释放它。 （实际上，您这样做了，因为您有一个混乱地称为字典，但在第1点，我建议您摆脱它。）一个更惯用的调用是：

     if（dict-＆gt; counter == dict-＆gt; size）{
       /*字典的增量酶大小*/
       dict-＆gt; size += dict-＆gt; size / 2; / *请参见第2点，上面 */
       char ** new_words = realloc（dict-＆gt;单词，dict-＆gt; size* sizeof（* new_words））;
       if（new_words == null）{
           / *报告分配错误，并释放您分配的所有内存 */
           /*然后可能退出（1），但是如果这是库函数，则只是
            *返回某种故障指示，以便呼叫者可以做
            *他们自己的清理。
            */
       }
       dict-＆gt;单词= new_words;
   }
   dict-＆gt;单词[dict-＆gt; counter] = word; / *请参阅下方4点 */
    

4. 您正在释放

   代码> word 在这里，因为它是在parse_line（）中分配的。但是，如果您知道自己还是要释放它，那么首先将其副本就没有太多意义了。您最好只使用它。 （但是您需要记录以下事实，即此功能是作为参数传递的单词所有权的所有权。）

   像您一样进行副本可能被认为是清洁的，但是 释放了这一参数，而呼叫者可以这样做。这将具有允许呼叫者提供一个没有动态分配的单词，或者将单词用于其他目的。

5. （在本摘要中没有指示，但仍然很重要）。 必须释放每个分配的内存的块。因此，您的程序应与执行malloc完全执行免费。但是你不那样做；您只需释放一系列单词指针，然后让单词指向该数组泄漏。您应该解决这个问题。 （请注意，您不需要额外的呼叫即可免费拨打Realloc，因为Realloc本身会释放旧块，如果它分配了新块。 免费。）