C内存分配问题

Question

因此，我有几个与我创建的 string 类型一起使用的函数。 其中之一创建动态分配的刺。 另一个获取所述字符串并扩展它。 最后一个释放字符串。 注意：函数名称已更改，但都是我自定义的。

string new = make("Hello, ");
adds(new, "everyone");
free(new);

上面的代码有效 - 它编译并运行良好。 下面的代码不起作用 - 它会编译、运行，然后

string new = make("Hello, ");
adds(new, "everyone!");
free(new);

代码之间的区别在于 adds() 函数添加了 1 个以上的字符（!）。 它添加的字符没有区别——只是长度。 为了完整起见，以下代码不起作用：

string new = make("Hello, ");
adds(new, "everyone");
adds(new, "!");
free(new);

奇怪的是，以下代码使用不同的函数 addc() （添加 1 个字符而不是字符串）起作用：

string new = make("Hello, ");
adds(new, "everyone");
addc(new, '!');
free(new);

以下代码也 起作用：做同样的事情，有效：

string new = make("Hello, everyone!");
free(new);

所有不起作用的错误都是这样的：（

test(526) malloc: *** error for object 0x100130: double free
*** set a breakpoint in malloc_error_break to debug

test 是我在其中使用的程序的极具描述性的名称。）

就函数而言在内部，我的 make() 是对 strlen() 的调用，两次调用 malloc() 以及对 memcpy( )，我的 adds() 是对 strlen() 的调用，对 realloc() 的调用，以及对memcpy()，而我的 free() 是对标准库 free() 的两次调用。

那么有什么想法为什么我会得到这个，或者我需要分解并使用调试器吗？ 我只能使用超过一定长度的 adds() 来获取它，而不是使用 addc() 来获取它。

分解并发布函数代码：

typedef struct _str {
  int _len;
  char *_str;
} *string;

string make(char *c)
{
    string s = malloc(sizeof(string));
    if(s == NULL) return NULL;
    s->_len = strlen(c);
    s->_str = malloc(s->_len + 1);
    if(s->_str == NULL) 
      {     
        free(s);
        return NULL;
      }
    memcpy(s->_str, c, s->_len);
    return s;
}

int adds(string s, char *c)
{
    int l = strlen(c);
    char *tmp;
    if(l <= 0) return -1;
    tmp = realloc(s->_str, s->_len + l + 1);
    if(!tmp) return 0;
    memcpy(s->_str + s->_len, c, l);
    s->_len += l;
    s->_str[s->_len] = 0;
    return s->_len;
}

void myfree(string s)
{
    if(s->_str) free(s->_str);
    free(s);
    s = NULL;
    return;
}

Answer 1

我要解决的一些潜在问题：

1/ 你的 make() 很危险，因为它没有跨字符串的空终止符进行复制。

2/ 在 myfree() 中将 s 设置为 NULL 也没什么意义，因为它是传递的参数，对实际没有影响 。

3/ 我不知道为什么如果添加的字符串长度为 0 或更小，则从 adds() 返回 -1 首先，它不能是负数。 其次，您似乎可以添加一个空字符串，这应该会导致不更改字符串并返回当前字符串长度。 如果失败（即 realloc() 不起作用），我只会返回 -1 的长度，并确保在发生这种情况时保留旧字符串。

4/ 即使 tmp 变量可以更改，您也不会将它存储到 s->_str 中 - 如果您增加内存，它很少会就地重新分配内存大小，但如果增量足够小以适合 malloc() 分配的任何额外空间，则这是可能的。 减小大小几乎肯定会就地重新分配，除非您的 malloc() 实现对不同大小的内存块使用不同的缓冲池。 但这只是一个旁白，因为您永远不会使用此代码减少内存使用量。

5/ 我认为您的特定问题是您仅为字符串分配空间，该字符串是指向结构的指针，而不是结构本身。 这意味着当您放入字符串时，您正在破坏内存区域。

这是我会编写的代码（包括更具描述性的变量名称，但这只是我的偏好）。

我已经更改：

• adds() 的返回值可以更好地反映长度和错误条件。 现在，如果无法扩展（并且原始字符串未受影响），它仅返回 -1 - 任何其他返回值都是新的字符串长度。
• myfree() 的返回值（如果您确实想要将字符串设置为 NULL），如“s = myfree (s)”。
• 在 myfree() 中检查 NULL 字符串，因为现在如果没有分配的 string->strChars 就永远不可能拥有已分配的 string。

就是这样，根据您的需要使用（或不使用:-)：

/*================================*/
/* Structure for storing strings. */

typedef struct _string {
    int  strLen;     /* Length of string */
    char *strChars;  /* Pointer to null-terminated chars */
} *string;

/*=========================================*/
/* Make a string, based on a char pointer. */

string make (char *srcChars) {
    /* Get the structure memory. */

    string newStr = malloc (sizeof (struct _string));
    if (newStr == NULL)
        return NULL;

    /* Get the character array memory based on length, free the
       structure if this cannot be done. */

    newStr->strLen = strlen (srcChars);
    newStr->strChars = malloc (newStr->strLen + 1);
    if(newStr->strChars == NULL) {     
        free(newStr);
        return NULL;
    }

    /* Copy in string and return the address. */

    strcpy (newStr->strChars, srcChars);
    return newStr;
}

/*======================================================*/
/* Add a char pointer to the end of an existing string. */

int adds (string curStr, char *addChars) {
    char *tmpChars;

    /* If adding nothing, leave it alone and return current length. */

    int addLen = strlen (addChars);
    if (addLen == 0)
        return curStr->strLen;

    /* Allocate space for new string, return error if cannot be done,
       but leave current string alone in that case. */

    tmpChars = malloc (curStr->strLen + addLen + 1);
    if (tmpChars == NULL)
        return -1;

    /* Copy in old string, append new string. */

    strcpy (tmpChars, curStr->strChars);
    strcat (tmpChars, addChars);

    /* Free old string, use new string, adjust length. */

    free (curStr->strChars);
    curStr->strLen = strlen (tmpChars);
    curStr->strChars = tmpChars;

    /* Return new length. */

    return curStr->strLen;
}

/*================*/
/* Free a string. */

string myfree (string curStr) {
    /* Don't mess up if string is already NULL. */

    if (curStr != NULL) {
        /* Free chars and the string structure. */

        free (curStr->strChars);
        free (curStr);
    }

    /* Return NULL so user can store that in string, such as
       <s = myfree (s);> */

    return NULL;
}

我能看到的唯一其他可能的改进是维护空间缓冲区和 strChars 的末尾以允许无需调用 malloc() 的扩展级别。

这将需要缓冲区长度和字符串长度，并更改代码以仅在字符串长度和新字符长度的组合大于缓冲区长度时分配更多空间。

这些都将被封装在函数中，因此 API 根本不会改变。 而且，如果您设法提供函数来减小字符串的大小，它们也不必重新分配内存，只需减少缓冲区的使用即可。 在这种情况下，您可能需要一个 compress() 函数来减少具有大缓冲区和小字符串的字符串。

Answer 2

make 中的第一个 malloc 应该是：

malloc (sizeof (struct _str));

否则，您只是为指向 struct _str 的指针分配了足够的空间。

Answer 3

 tmp = realloc(s->_str, s->_len + l + 1);

realloc 可以返回指向所请求块的新指针。 您需要添加以下代码行：

 s->_str = tmp;

在一种情况下它不会崩溃，但在添加一个字符后会崩溃的原因可能只是因为内存的分配方式。 可能存在最小分配增量（在本例中为 16）。 因此，当您为 hello 分配前 8 个字符时，它实际上分配了 16 个字符。当您添加每个人时，它不会超过 16 个字符，因此您会得到原始块。 但对于 17 个字符，realloc 返回一个新的内存缓冲区。

尝试更改添加如下

 tmp = realloc(s->_str, s->_len + l + 1);
 if (!tmp) return 0;
 if (tmp != s->_str) {
     printf("Block moved!\n"); // for debugging
     s->_str = tmp;
 }

Answer 4

在函数 adds 中，您假设 realloc 不会更改需要重新分配的内存块的地址：

tmp = realloc(s->_str, s->_len + l + 1);
if(!tmp) return 0;
memcpy(s->_str + s->_len, c, l);

虽然这对于小型重新分配可能是正确的（因为块的大小您获得的内存通常会四舍五入以优化分配），但通常情况并非如此。 当 realloc 返回一个新指针时，您的程序仍然使用旧指针，从而导致问题：

memcpy(s->_str + s->_len, c, l);

Answer 5

可能应该发布代码，但是双重释放意味着您在同一个指针上调用释放两次。

1. 您是否在 strlen 中为末尾的 \0 字节添加 1？
2. 释放指针后，是否将成员变量设置为 NULL，以便不再释放（或设置为已知的错误指针，如 0xFFFFFFFF）

Answer 6

为什么“我的 free() 是对标准库 free() 的两次调用”。 为什么要打两次免费电话？ 您应该只需要拨打一次。

请发布您的adds(); 和 free() 函数。