realloc() 没有赋值问题

Question

我的一个同学给我发了一个代码，问我怎么了。它是这样的：

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

int main()
{
    int *d_array, number, divisor_count, i, size = 1;
    char answer;

    d_array = (int*) malloc(size * sizeof(int));

    do
    {
        printf("\nEnter a number:  ");
        scanf("%d", &number);
        divisor_count = 0;
        for(i = 2; i < number; i++)
            if (number % i == 0) divisor_count++;
        if(divisor_count == 0)
        {
            realloc(d_array,(size + 1) * sizeof(int));
            d_array[size - 1] = number;
            size++;
        }
        printf("\nIs there another number? y/n ");
        getchar();
        answer = getchar();
    } while (answer == 'y');

    for(i = 0; i < size - 1; i++)
        printf("\n%d", d_array[i]);

    return 0;
} 

它应该从用户那里获取数字并保留质数并最后打印它们。我的计算机上的输出类似于：

Enter a number:  3
Is there another number? y/n y
Enter a number:  5
Is there another number? y/n y
Enter a number:  8
Is there another number? y/n y
Enter a number:  7
Is there another number? y/n y
Enter a number:  2
Is there another number? y/n n
4072680
5
7
2

代码中还有其他内容，但最大的问题显然是没有分配 realloc() 的返回值。但奇怪的是，这是我的问题，为什么这段代码显示第一个素数错误，而其他素数正确？动态数组的地址可能会改变，但为什么第二个和其余的都是正确的，而不是第一个？

编辑：好的，我问这个问题的原因是为了尝试理解这段代码中realloc()的行为，如果您有好的资源请分享。当重新分配内存时（当释放旧内存时），realloc() 是否会更改旧内存位置的内容？

Answer 1

始终这样做：

void* new_ptr = realloc(ptr, new_size);
if(!new_ptr) error("Out of memory");
ptr = new_ptr;

原因是 realloc() 可能无法在已分配的块中容纳请求的大小。如果需要移动到另一个内存块，它将复制从先前分配的内存中删除数据，释放旧内存块，然后返回新内存块。

另外，如果 realloc() 返回 NULL，则意味着失败。在这种情况下， ptr 指向的内存必须在某个时刻被释放，否则就会出现内存泄漏。换句话说，永远不要这样做：

ptr = realloc(ptr, new_size);

Answer 2

如果您调用未定义的行为，那么如果不查看操作系统和编译器内部结构，就无法解释结果。

我知道这不是一个非常令人满意的答案。但是，如果您可以描述其背后的逻辑，那么它就不会真正被称为未定义的行为！

Answer 3

这将向您展示一些正在发生的事情：

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

void dbg_print_array(unsigned sz, const int * array, const char * label) {
     fprintf(stderr, "{%s:\t%p:\t", label, array);
     while (sz--) {
         fprintf(stderr, " %x ", *array++);
     }
     fprintf(stderr, "}\n");
}

int main()
{
    int *d_array, number, divisor_count, i, size = 1;
    char answer;

    d_array = (int*) malloc(size * sizeof(int));
    dbg_print_array(size, d_array, "Initial");

    do
    {
        printf("\nEnter a number:  ");
        scanf("%d", &number);
        divisor_count = 0;
        for(i = 2; i < number; i++)
            if (number % i == 0) divisor_count++;
        if(divisor_count == 0)
        {
            int * p;
            dbg_print_array(d_array, size, "pre-realloc");
            p = realloc(d_array,(size + 1) * sizeof(int));
            dbg_print_array(d_array, size+1, "post-realloc (d_array)");
            dbg_print_array(p, size+1, "post-realloc (p)");
            d_array[size - 1] = number;
            size++;
        }
        printf("\nIs there another number? y/n ");
        getchar();
        answer = getchar();
    } while (answer == 'y');

    for(i = 0; i < size - 1; i++)
        printf("\n%d", d_array[i]);

    return 0;
} 

至于为什么这些数据这么快就被覆盖，很难说。不同的堆分配实现可能对此表现得非常不同。由于重新分配是以如此小的步骤完成的（数组每次增长 1）realloc 将被频繁调用。

因为即使您和我通常可能认为未分配的堆空间未使用，但堆分配和释放函数确实会在那里存储一些数据以跟上情况。由于每次调用 realloc 都会读取此数据，并且提供的程序会写入 realloc 可能假定由堆分配例程拥有的数据，因此它可能正在读取该程序已覆盖的内容（它每次都会写掉最初分配的空间的末尾）通过循环）。读取此损坏的数据后，realloc 可能会根据所读取的内容做出决定，从而导致谁知道什么。此时，在程序中，您应该将每个行为视为未定义，因为为正常操作所做的基本假设不再有效。

编辑

通过检查上述代码的输出，您应该能够确定 realloc 实际上何时返回与传递的指针不同的指针（我的猜测是为读入的最后一个整数腾出空间，在您的示例中，因为 malloc 第一次分配可能会舍入为 16 个字节 - 也因为 realloc 没有中止，可能是因为它从未传递过无效指针） 。

当 realloc 未返回与传递的指针相同的指针时，相邻的 post-realloc 打印语句将具有不同的地址（为它们打印的第一个数字）。

Answer 4

问题在于，在realloc之后，d_array指向的内存被认为是空闲的，因此代码实际上写入了空闲内存。似乎同时内存被分配给不同的东西（由 scanf 使用？），所以它的开头被覆盖。当然，这是完全未定义的：释放的内存的任何部分都可能随时被覆盖。

Answer 5

由于您似乎最想知道为什么会从未定义的行为中获得可重复（即使不正确）的输出，因此这里有一种情况可能会导致您所看到的结果。我认为理解未定义行为背后的潜在机制可能很有价值 - 请记住，这是假设的，并且可能并不是您所看到的真正原因。对于未定义的行为，您看到的结果可能会从一次编译到下一次编译或从一次运行到下一次运行发生变化（对于一种奇怪的情况，仅更改具有未定义行为的程序中的变量名称就会更改程序的输出，请参阅< a href="https://stackoverflow.com/questions/4575697/unexpected-output-from-bubblesort-program-with-msvc-vs-tcc/4577565#4577565">使用 MSVC 与 TCC 的冒泡排序程序的意外输出）。

1. d_array 通过在 do/whilemalloc(size * sizeof(int)) 进行初始化code> 进入循环。 d_array 指针在此之后永远不会更改（即使它可能不再指向已分配的内存，正如我们稍后会看到的）

2. 第一次存储值时，realloc () 被调用，但库发现它不需要更改最初给定的块并返回传递给它的值。因此 3 存储在该块的开头。请注意，这仍然是一个错误，因为您的程序无法知道 d_array 是否仍然有效，因为您忽略了 realloc() 的返回值。< /p>

3. 当输入5时，会再次调用realloc()。这次，库决定它必须分配不同的块。它会这样做（在复制 d_array 指向的内容之后）。此重新分配的部分结果是 d_array 指向的块被释放，并且库的簿记会用 40726803 >。也许是图书馆关心的事情的指针——谁知道呢。最主要的是，该块现在再次属于库，并且它（而不是您）可以用它做它想做的事。

4. 现在5被写入d_array + 1（这不是一个有效的操作，因为d_array指向的块已经被释放） 。因此，d_array[0] == 4072680 和 d_array[1] == 5。

5. 从此时起，通过 d_array 存储的所有值都会进入已释放的块，但无论出于何种原因，库都不会注意到正在发生的堆损坏。只是运气好（如果你想找到 bug，那就运气不好了）。没有任何内容被写入 realloc() 可能实际重新分配的块。

注意 - 就像我说的，所有这些都是对该行为的一种可能的解释。实际细节可能有所不同，但这并不重要。一旦您访问了已释放的内存分配（无论是读取还是写入），所有的赌注都会消失。未定义行为的底线规则是任何事情都会发生。

Answer 6

尝试一下：

d_array = realloc(d_array,(size + 1) * sizeof(int));

这样做并且在我的计算机上运行良好。

如果你使用 gcc，gcc -Wall -o 会给你你正在寻找的警告。

你 realloc() 但你不使用分配的新内存。简单来说。它仍然指向旧的块（取决于 realloc() 是否使用相同的块或将其移动到不同的位置）。如果你很“幸运”并且使用了同一个块，那么你只需继续写入，否则你将写入旧位置并最终写入不应该写入的位置（因为 realloc() free( ) 在内部更改旧块。 realloc() 不会更改指针变量，只是重新分配空间。正如评论所说，您需要检查分配的新空间是否包含旧缓冲区的数据（只要分配的新内存大于旧内存）。 1）旧内存的内容没有改变，但旧的地方被释放。

Answer 7

我认为你必须像这样使用 realloc：

d_array = realloc(d_array,(size + 1) * sizeof(int));

不仅仅是：

realloc(d_array,(size + 1) * sizeof(int));

我看到的另一个问题是 size=1 最初，所以代码第一次运行时是这样做的：

realloc(d_array,(size + 1) * sizeof(int));

size + 1 = 2（为 2 个整数分配内存，但您只需要一个。）解决方案可能是从 0 开始大小。