1

这是我的代码，它应该为存储字符串动态分配内存：

#define _XOPEN_SOURCE 700

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

int main()
{
    char **path = NULL;

    path = (char **) malloc(sizeof(char *));

    for (int i = 0; i < 5; i++)
    {
            path[i] = strdup("TEST");
            path = (char **) realloc(path, sizeof(char *));
    }

    for (int i = 0; i < 5; i++)
    {
            printf("%s\n", path[i]);
    }

    return 0;
}

上面的代码在我重新分配内存的那一行中断。

根据我的说法，在第一个 malloc 上分配给路径的内存如下所示：

path -----> |   char *  | // path points to a character pointer which       inturn is pointing to nothing(Dangling).

因此，在程序运行该行的这个时间点：

path = (char **) malloc(sizeof(char *));

path[0] 当前在边界内，我们可以在 path[0] 处存储一个且只有一个字符串的起始地址，此时 path[1] 应该超出边界。

因此，当我们第一次进入 for 循环时，我们将字符串的地址存储在 path[i] 中，我们将能够：

path[0] = strdup("TEST"); // is in bounds.

要存储另一个字符串，我们需要更多的路径应该指向的内存。所以我在下面的行中做了 realloc：

path = (char **) realloc(path, (char *));

因此，根据我的说法，内存中的路径应该如下所示：

path --------->|old char *|----->"TEST"
  |----------->|new char *|----->(Dangling) // Pointing Nowhere.

因此，现在 path[1] 也在界限内，我们应该能够使用该内存位置。所以我不知道为什么我在运行我的代码时会出现这个分段错误：

*** glibc detected *** ./dynamic: realloc(): invalid next size: 0x0000000000602010 ***
======= Backtrace: =========
/lib64/libc.so.6(+0x75018)[0x7f743153e018]
/lib64/libc.so.6(+0x7ae96)[0x7f7431543e96]
/lib64/libc.so.6(realloc+0xfa)[0x7f74315441aa]
./dynamic[0x40067f]
/lib64/libc.so.6(__libc_start_main+0xe6)[0x7f74314e7bc6]
./dynamic[0x400569]
======= Memory map: ========
00400000-00401000 r-xp 00000000 00:27 14459340                           /home/xpansat/c/basic/dynamic
00600000-00601000 r--p 00000000 00:27 14459340                           /home/xpansat/c/basic/dynamic
00601000-00602000 rw-p 00001000 00:27 14459340                           /home/xpansat/c/basic/dynamic
00602000-00623000 rw-p 00000000 00:00 0                                  [heap]
7f742c000000-7f742c021000 rw-p 00000000 00:00 0 
7f742c021000-7f7430000000 ---p 00000000 00:00 0 
7f74312b2000-7f74312c8000 r-xp 00000000 fd:01 173                        /lib64/libgcc_s.so.1
7f74312c8000-7f74314c7000 ---p 00016000 fd:01 173                        /lib64/libgcc_s.so.1
7f74314c7000-7f74314c8000 r--p 00015000 fd:01 173                        /lib64/libgcc_s.so.1
7f74314c8000-7f74314c9000 rw-p 00016000 fd:01 173                        /lib64/libgcc_s.so.1
7f74314c9000-7f743161d000 r-xp 00000000 fd:01 27                         /lib64/libc-2.11.1.so
7f743161d000-7f743181d000 ---p 00154000 fd:01 27                         /lib64/libc-2.11.1.so
7f743181d000-7f7431821000 r--p 00154000 fd:01 27                         /lib64/libc-2.11.1.so
7f7431821000-7f7431822000 rw-p 00158000 fd:01 27                         /lib64/libc-2.11.1.so
7f7431822000-7f7431827000 rw-p 00000000 00:00 0 
7f7431827000-7f7431846000 r-xp 00000000 fd:01 20                         /lib64/ld-2.11.1.so
7f7431a14000-7f7431a17000 rw-p 00000000 00:00 0 
7f7431a44000-7f7431a45000 rw-p 00000000 00:00 0 
7f7431a45000-7f7431a46000 r--p 0001e000 fd:01 20                         /lib64/ld-2.11.1.so
7f7431a46000-7f7431a47000 rw-p 0001f000 fd:01 20                         /lib64/ld-2.11.1.so
7f7431a47000-7f7431a48000 rw-p 00000000 00:00 0 
7fff62f8c000-7fff62fa2000 rw-p 00000000 00:00 0                          [stack]
7fff62fff000-7fff63000000 r-xp 00000000 00:00 0                          [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0                  [vsyscall]

我不知道我做错了什么，因为如果我改变了我的 realloc 行，我就能够运行我的代码，如下所示：

path = (char **) realloc(sizeof(char *)*8);

如果是乘以 8 我的代码运行，但我想分配我想要的确切内存，任何想法为什么没有乘以 8 就无法工作。

4

2 回答 2

5

这里

path = (char **) malloc(sizeof(char *));

您正在分配一个指向 的指针char，即一个指向 C-“字符串”的指针的空间。

那么这里：

for (int i = 0; i < 5; i++)
{
   path[i] = strdup("TEST");
   path = (char **) realloc(path, sizeof(char *));
}

您不仅使用了一个指向 C-“字符串”的指针，而且重新分配更多的只是重新分配与以前相同的大小，但实际上您访问就像您在每次迭代中为一个指针添加了内存一样。

这样做会覆盖未分配的内存（或已经被其他东西使用）并弄乱程序的内存管理。

一个更直接的方法是：

  ...

  char ** path = NULL;

  for (size_t i = 0; i < 5; ++i)
  {
    path = realloc(path, (i+1) * sizeof(*path));
    path[i] = strdup("TEST");
  }

  ...
于 2013-07-02T12:28:35.097 回答
4

跟随你的风格，改变

path = (char **) realloc(path, sizeof(char *));

至

path = realloc(path, (i+2) * sizeof(char *));

这分配给下一个循环。如果您想在每个循环中重新分配，则预先分配更有意义，如下所示：

path = realloc(path, (i+1) * sizeof(char *));
path[i] = strdup("TEST");

或者

就像其他人说的那样，预先分配所有内存path = malloc(5 * sizeof(char *))。删除 (char **) 的演员表是首选的编码实践。

或者

预先分配所有内存

path = calloc(5, sizeof(char *));

这比 calloc(num,size) 有 2 个好处malloc(size)。内存是零填充的。如果 num * size 的乘法溢出（在这种情况下显然不是），calloc()仍然会正确处理它。

另一种编码实践认为： usingptr = malloc(sizeof(*ptr))比ptr = malloc(sizeof(char *)). 如果*ptr更改类型（即使在这里不太可能），则在各种malloc()调用中都不需要更改编码。（也适用于 realloc() 和 calloc()。）

于 2013-07-02T12:28:31.410 回答