ABR：数组越界读
ABW：数组越界写
BFM：释放错误的内存块
BRP：错误的重新分配地址参数
CGB：损坏的保护块
DFM：双重释放内存
FMR：读取释放的内存
FMW：写入释放的内存
FRP：释放的重新分配参数
IMR：无效的内存读取
IMW：无效的内存写入
MLK：内存泄漏
OLP：重叠源和目标
PIR：部分初始化的读取
SBR：堆栈越界读
SBW：堆栈越界写
UAR：读取未分配的内存
UAW：写入未分配的内存
UMR：读取未初始化的内存
本节介绍可能的错误原因以及发生错误的代码示例。
可能的原因：试图读取超出数组边界的内存。
示例：
int a[5];
. . .
printf("a[5] = %d\n",a[5]); // Reading memory beyond array bounds
可能的原因：试图写入超出数组边界的内存。
示例：
int a [5];
. . .
a[5] = 5; // Writing to memory beyond array bounds
可能的原因：向 free()() 或 realloc()() 传递了一个非堆数据指针。
示例：
#include <stdlib.h>
int main()
{
int *p = (int*) malloc(sizeof(int));
free(p+1); // Freeing wrong memory block
}
示例：
#include <stdlib.h>
int main()
{
int *p = (int*) realloc(0,sizeof(int));
int *q = (int*) realloc(p+20,sizeof(int[2])); // Bad address parameter for realloc
}
可能的原因：写入超出了动态分配的数组末尾，或者在“红色区域”中。
示例：
#include <stdio.h>
#include <stdlib.h>
int main() {
int *p = (int *) malloc(sizeof(int)*4);
*(p+5) = 10; // Corrupted array guard block detected (only when the code is not annotated)
free(p);
return 0;
}
可能的原因：多次使用同一指针调用 free()()。在 C++ 中，多次对同一指针使用 delete 操作符。
示例：
int *p = (int*) malloc(sizeof(int));
free(p);
. . . // p was not assigned a new value between the free statements
free(p); // Double freeing memory
示例：
int *p = (int*) malloc(sizeof(int));
free(p);
. . . // Nothing assigned to p in between
printf("p = 0x%h\n",p); // Reading from freed memory
示例：
int *p = (int*) malloc(sizeof(int));
free(p);
. . . // Nothing assigned to p in between
*p = 1; // Writing to freed memory
示例：
#include <stdlib.h>
int main() {
int *p = (int *) malloc(sizeof(int));
free(0);
int *q = (int*) realloc(p,sizeof(it[2])); //Freed pointer passed to realloc
}
可能的原因：分别从那些没有半字对齐、单字对齐或双字对齐的地址中读取 2 个、4 个或 8 个字节。
示例：
#include <stdlib.h>
int main()
{
int *p = 0;
int i = *p; // Read from invalid memory address
}
可能的原因：分别从那些没有半字对齐、单字对齐或双字对齐的地址中写入 2 个、4 个或 8 个字节。向文本地址写入、向只读数据区 (.rodata) 写入或向已由 mmap 设置为只读的页面写入。
示例：
int main()
{
int *p = 0;
*p = 1; // Write to invalid memory address
}
可能的原因：分配了内存，但是在退出或终止函数之前未释放。
示例：
int foo()
{
int *p = (int*) malloc(sizeof(int));
if (x) {
p = (int *) malloc(5*sizeof(int)); // will cause a leak of the 1st malloc
}
} // The 2nd malloc leaked here
可能的原因：指定的源、目标或长度不正确。如果源和目标重叠，则程序的行为是不确定的。
示例：
#include <stlib.h>
#include <string.h>
int main() {
char *s=(char *) malloc(15);
memset(s, 'x', 15);
memcpy(s, s+5, 10);
return 0;
}
示例：
#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p = (int*) malloc(sizeof(int));
*((char*)p) = 'c';
printf("*(p = %d\n",*(p+1)); // Accessing partially initialized data
}
可能的原因：读取本地数组时越过了起始或结束边界。
示例：
#include <stdio.h>
int main() {
int a[2] = {0, 1};
printf("a[-10]=%d\n",a[-10]); // Read is beyond stack frame bounds
return 0;
}
可能的原因：写入本地数组时越过了起始或结束边界。
示例：
#include <stdio.h>
int main() {
int a[2] = {0, 1};
a[-10] = 2; // Write is beyond stack frame bounds
return 0;
}
可能的原因：溢出堆块边界或访问已释放堆块的迷失指针。
示例：
#include <stdio.h>
#include <stdlib>
int main()
{
int *p = (int*) malloc(sizeof(int));
printf("*(p+1) = %d\n",*(p+1)); // Reading from unallocated memory
}
可能的原因：溢出堆块边界或访问已释放堆块的迷失指针。
示例：
#include <stdio.h>
#include <stdlib>
int main()
{
int *p = (int*) malloc(sizeof(int));
*(p+1) = 1; // Writing to unallocated memory
}
可能的原因：读取尚未初始化的局部数据或堆数据。
示例：
#include <stdio.h>
#include <stdlib>
int main()
{
int *p = (int*) malloc(sizeof(int));
printf("*p = %d\n",*p); // Accessing uninitialized data
}