Realloc 在结构中具有指针数组

Question

在 C89 中，以下代码可以正常工作：

typedef struct{
    int size;
    int **ptr;
}foo;

int main()
{
    foo *var;

    var = malloc(sizeof(foo) + 2 * sizeof(int*));

    int a = 3, b = 6;

    var->ptr[0] = &a;
    var->ptr[1] = &b;

    printf("%d %d\n", (*var->ptr[0]), (*var->ptr[1]));

    return 0;
}

执行时显示：3 6

但如果我替换

var = malloc(sizeof(foo) + 2 * sizeof(int*));

与

var = malloc(sizeof(foo));
var = realloc(var, sizeof(foo) + 2 * sizeof(int*));

它在没有任何警告的情况下编译，但在以下行出现分段错误：

var->ptr[0] = &a;

我真的不知道我做错了什么，所以我很感激任何意见。我是初学者，如果我的错误很明显，我深表歉意。

谢谢。

Answer 1

我会说这在 C89 中也是错误的。

malloc(sizeof(foo) + 2 * sizeof(int*));

分配的比你需要的多，但不是你期望的那样。

+-------+------------+---------+--------+
|  size | ptr        |  int*   | int*   |
+-------+------------+---------+--------+

|  sizeof foo        | 2 * sizeof(int*) |

如您所见，var->foo 仍然未初始化，无论有多少额外字节 你已经分配了，所以

var->ptr[0] = &a;
var->ptr[1] = &b;

会失败。

你应该做的是：

var = malloc(sizeof *var);

var->ptr = malloc(2 * sizeof *var->ptr);

var->ptr[0] = &a;
var->ptr[1] = &b;

然后它看起来像这样

                                     | int |     | int |

                                     +-----+     +-----+
                                     |  a  |     |  b  |
                                     +-----+     +-----+
                                         ^         ^
                                         |         |
                                         |         |
+-------+------------+  points to     +---------+--------+
|  size | ptr        | ------------>  | int*    | int*   |
+-------+------------+                +---------+--------+

|  sizeof foo        |                | 2 * sizeof(int*) |

不要忘记检查malloc 的返回值并释放内存 之后。

编辑

可行的方法是：

var = malloc(sizeof(foo) + 2 * sizeof(int*));
var->ptr = (int**) ( ((char*) var) + sizeof *var );

您设置var->pointer 以指向struct 的内存。尽管 这可能有效，我认为这很丑陋，我会拒绝提交 有这样的同事。

Answer 2

在 Windows 10 的 Visual Studio 中，您的两个示例都不起作用。这是因为结构在这两种情况下都未初始化。

箭头操作：

foo->bar

是以下的简写：

(*foo).bar

因此，如果“foo”结构变量未初始化，取决于编译器，结构内的指针将指向内存中的随机位置。

所以，当你这样使用箭头运算符时：

var->ptr[0] = &a;

你所做的是：

(*var).ptr[0] = &a;

因此，基本上，您尝试将“a”的地址写入内存中您不应该访问的位置。这就是您遇到分段错误的原因。

但是，如果您已经对其进行了初始化：

int goodmemorylocation = 0;
var->ptr = &goodmemorylocation; // You change the location of your pointer to an accessible location in memory

那么您的代码在我的系统中适用于这两种情况。

也许，在您的系统中，您使用 malloc 的第一个示例以某种方式指向了您内存中的正确地址。这就是它起作用的原因。

Answer 3

问题是您没有分配ptr 指向任何东西，所以它指向随机内存，并且ptr[index] 的任何访问都是未定义的行为。

像乔纳森的回答那样更改ptr 的声明是最安全的选择，例如：

typedef struct{
    int size;
    int* ptr[1]; // or 0 if your compiler supports it
}foo;

int main()
{
    foo *var;

    var = malloc(offsetof(foo, ptr));
    if (var) {
        var->size = 0;
        ...
    }

    foo *newvar = realloc(var, offsetof(foo, ptr) + (2 * sizeof(int*)));
    if (newvar) {
        var = newvar;
        var->size = 2;

        int a = 3, b = 6;

        var->ptr[0] = &a; // <-- OK!
        var->ptr[1] = &b; // <-- OK!

        printf("%d %d\n", *(var->ptr[0]), *(var->ptr[1]));
    }

    free(var);
    return 0;
}

但是，如果出于某种原因，您无法更改 ptr 的声明（例如，foo 与现有 API 一起使用），那么您可以改为：

typedef struct{
    int size;
    int **ptr;
}foo;

int main()
{
    foo *var = malloc(sizeof(foo));
    if (var) {
        var->size = 0;
        var->ptr = NULL; // <-- add this!
        ...
    }

    foo *newvar = realloc(var, sizeof(foo) + (2 * sizeof(int*)));
    if (newvar) {
        var = newvar;
        var->size = 2;
        var->ptr = (int**)(var + 1); // <-- add this!

        int a = 3, b = 6;

        var->ptr[0] = &a; // <-- OK!
        var->ptr[1] = &b; // <-- OK!

        printf("%d %d\n", *(var->ptr[0]), *(var->ptr[1]));
    }

    free(var);
    return 0;
}

在后一种情况下，确保每次想要（重新）分配var 时都执行相同的ptr 分配。我会将该逻辑包装在一组辅助函数中，例如：

typedef struct{
    int size;
    int **ptr;
}foo;

foo* createFoo(int size)
{
    foo *var = malloc(sizeof(foo) + (size * sizeof(int*)));
    if (var) {
        var->size = size;
        var->ptr = (int**)(var + 1);
    }
    return var;
}

foo* resizeFoo(foo **var, int newSize)
{
    foo *newvar = realloc(*var, sizeof(foo) + (newSize * sizeof(int*)));
    if (newvar) {
        newvar->size = newSize;
        newvar->ptr = (int**)(newvar + 1);
        *var = newvar;
    }
    return newvar;
}

int main()
{
    foo *var = createFoo(0);
    ...

    if (resizeFoo(&var, 2)) {
        int a = 3, b = 6;

        var->ptr[0] = &a; // <-- OK!
        var->ptr[1] = &b; // <-- OK!

        printf("%d %d\n", *(var->ptr[0]), *(var->ptr[1]));
    }

    free(var);
    return 0;
}

Answer 4

我认为你的声明是错误的。以下行假设ptr 指向一些内存，而实际上它根本没有被初始化！

var->ptr[0] = &a;

如果你的编译器支持它，它不应该更像这样吗：

typedef struct{
    int size;
    int* ptr[0];
}foo;

否则，将ptr[0] 更改为ptr[1]，并根据结构已包含一个元素的事实调整您的计算。

注意：一旦写入错误的地址，结果是不确定的。你有一个问题，但它只出现在一种情况下。在这两种情况下问题仍然存在。

Answer 5

你需要修复结构：

typedef struct{
    int size;
    int *ptr;
}foo;

还有代码：

 var = malloc(sizeof(foo));
 var->ptr = malloc(2 * sizeof(int));

 int a = 3, b = 6;
 // store a and b in array, not their addresses
 var->ptr[0] = a;
 var->ptr[1] = b;

假设您希望数组中有 2 个条目。当然，忽略我没有测试 malloc() 的结果这一事实。

如果要调整数组大小，只需重新分配 var->ptr 而不是 var。