使用 malloc 分配内存造成的堆损坏：为什么会发生？

Question

好的，我试图实现 memmove 只是作为一个编程练习，当我尝试使用 malloc 时，我在 memmove 函数中遇到内存访问冲突。这是函数：

//Start

void* MYmemmove (void* destination, const void* source, size_t num) { 

    int* midbuf = (int *) malloc(num); // This is where the access violation happens.
    int* refdes = (int *) destination; // A pointer to destination, except it is casted to int*
    int* refsrc = (int *) source; // Same, except with source
    for (int i = 0;num >= i;i++) { 
        midbuf[i] = *(refsrc + i); // Copy source to midbuf
    }
    for (int i = 0;num >= i;i++) { 
        refdes[i] = *(midbuf + i); // Copy midbuf to destination
    } 
    free(midbuf); // free midbuf 
    refdes = NULL; // Make refdes not point to destination anymore
    refsrc = NULL; // Make refsrc not point to source anymore
    return destination;
}

顺便说一句，我是指针的新手，所以如果有一些错误不要感到惊讶。 我做错了什么？

Answer 1

请注意其他建议！答案取决于您的 memmove 将如何使用。其他答案表明您应该更改 malloc 调用以考虑 int 的大小。但是，如果您的 memmove 函数将用于表示“移动此数量的 字节”，那么实现将是错误的。我会改为使用 char*，因为它可以一次性解决几个问题。

另外，int 通常为 4 个字节，char 通常为 1 个字节。如果您收到的void* 地址不是字对齐的（不是 4 字节的倍数），您将遇到问题：要复制非字对齐的 int，您将不得不进行多次读取和昂贵的位掩码。这是低效的。

最后，内存访问冲突发生了，因为您每次都在增加 midbuf int 指针，并且每次向前移动 4 个字节。但是，您只分配了 num bytes，因此最终会尝试访问超出分配区域的末尾。

/** Moves num bytes(!) from source to destination */
void* MYmemmove (void* destination, const void* source, size_t num) { 

    // transfer buffer to account for memory aliasing
    // http://en.wikipedia.org/wiki/Aliasing_%28computing%29
    char * midbuf = (char *) malloc(num); // malloc allocates in bytes(!)
    char * refdes = (char *) destination;
    char * refsrc = (char *) source;

    for (int i = 0; i < num; i++) { 
        midbuf[i] = *(refsrc + i); // Copy source to midbuf
    }

    for (int i = 0; i < num; i++) { 
        refdes[i] = *(midbuf + i); // Copy midbuf to destination
    } 

    free(midbuf); // free midbuf
    // no need to set the pointers to NULL here.
    return destination;
}

通过逐字节复制，我们避免了对齐问题，以及 num 本身可能不是 4 个字节的倍数的情况（例如 3，因此 int 对于该移动来说太大了）。

Answer 2

用 malloc 替换字符串：

int* midbuf = (int *) malloc(num*sizeof(int)); 

问题是您分配的不是num int 元素，而是num 字节。

Answer 3

int* midbuf = (int *) malloc(num); // This is where the access violation happens.
int* refdes = (int *) destination; // A pointer to destination, except it is casted to int*
int* refsrc = (int *) source; // Same, except with source
for (int i = 0;num >= i;i++) { 
    midbuf[i] = *(refsrc + i); // Copy source to midbuf
}

您 malloc 仅 num 字节，但在循环中，您尝试复制 num ints。由于int 通常占用超过一个字节，因此您的访问超出了范围。

Answer 4

内存访问冲突？

您正在尝试访问您无权访问的内存。也许你有一个空指针或者指针指向另一个程序或代码段。

Answer 5

问题是您将num 字节分配到midbuf，然后将num 整数复制到其中。由于int 在大多数平台上大于一个字节，因此您遇到了问题。将您的malloc 更改为num*sizeof(int)，您将不会遇到这个问题。

Answer 6

有两个问题需要看

1.内存空间

（前提是MYmemmove 执行自定义实现以移动ints 如问题所示）

    int* midbuf = (int *) malloc(num * sizeof(int));

malloc 是基于字节的，将分配 num 个字节。 int * 是指向 ints 的指针。意思是midbuf[x] 将从midbuf + sizeof(int)*x 访问内存。您想分配 num ints （int 的大小取决于体系结构，通常为 4 或 2 个字节）。因此malloc(num * sizeof(int))。

2。数组索引

    for (int i = 0;num > i;i++) { 

在 C（和 C++）中，数组是从 0 开始的，即第一个索引是 0。你做对了。但这也意味着如果您保留 num ints，则可用索引将从 0 到 num-1。在您的循环中，i 将在 0 到 num 之间变化，这要归功于条件 num >= i，这意味着您将访问 num+1 项目。所以num > i（或i < num）会是更好的for条件。

Answer 7

#include <stdlib.h>  // did you included this?


void* MYmemmove (void* destination, const void* source, size_t num) { 

    char *Source = source, *Destination = destination;
    char *Middle = malloc( sizeof(char) * num );    // midbuf

    for (int i = 0; i < num ; i++) { 
        Middle[i] = Destination[i]; // Copy source to midbuf
    }
    for (int i = 0; i < num ; i++) { 
        Destination[i] = Middle[i]; // Copy midbuf to destination
    }

    free(Middle);                   // free memory allocated previously with malloc
    return destination;
}

可能会发生访问冲突，因为您没有包含 malloc 所需的库（如果您忘记了函数定义，标准 c 不会在您的脸上抛出错误）。您不需要将指针标记为 NULL，因为 C 中没有垃圾收集（指针就是指针。指向内存中某个点的地址，而不是内存本身）。

想想像这样的指针

指针地址 0x1243 0x4221 目的地 -> {某种数据}

目的地 = 0x1243 *Destination = 当前地址 0x4221 处的任何值

您也不能索引 void 指针。您必须首先将它们转换为某种类型，以便编译器知道它们需要多少偏移量。

目的地[x] = *(目的地+x)

char 是 1 个字节，所以 char 指针实际上会移动 x 个字节，但 int 是 4 个字节，而 int 指针会移动 4*x 个字节。如果这听起来很技术性，请不要太担心，当你达到非常低的水平时，它会很重要;)