189 8069 5689
1. 栈区：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限，所以有时候会出现栈溢出的情况。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区：一般由程序员分配、释放， 若程序员不释放，程序结束时可能由操作系统回收，分配方式类似于链表。
3. 数据段 ( 静态区 static ) 存放全局变量、静态数据，程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。
声明在我们平时写程序时，创建的变量都会在底层开辟内存。C语言 的内存布局分为三大块：栈区、堆区、静态区。其中栈区是我们平时使用最多的区域，栈区的使用习惯：先使用高地址处的空间，再使用低地址处的空间。然而栈区的使用总是有限的，所以本篇博客重点介绍如何使用堆区的内存。
malloc - memory allocate - 分配一段连续的内存空间
void* malloc (size_t size);
// 返回值：申请内存成功，则返回开辟好空间的头指针；申请内存失败，则返回 NULL
// 参数：以字节为单位的申请值free - 释放并回收内存
void free (void* ptr);
// 参数：ptr 为先前用 malloc、calloc 或 realloc分配的内存块的头指针
// 注意：一定要是头指针，而不是中间的指针，否则就会出现释放内存不干净的情况#include#includeint main() { int* p = (int*) malloc(40); // 申请空间
if (p == NULL) {// 内存分配失败的情况
perror("malloc");
return 1;
}
for (int i = 0; i< 10; i++) {*(p + i) = i; // 为刚刚开辟的空间放入值
}
free(p); // free 将刚刚系统开辟的空间，再回收掉
p = NULL; // 为了防止 ptr 成为野指针，所以将其置成 NULL
return 0;
} calloc - 分配一段连续的内存空间并清零
calloc 函数 和 malloc 函数的使用思想基本相同，只不过前者在分配内存之后，又做了清零的步骤。
void* calloc (size_t num, size_t size);
// 返回值：申请内存成功，则返回开辟好空间的头指针；申请内存失败，则返回 NULL
// 参数：num 表示元素个数，size 表示每个元素的字节大小#include#includeint main() {int* p = (int*) calloc(10, sizeof(int)); // 申请 10*4 = 40 个字节
if (p == NULL) {perror("calloc");
return 1;
}
for (int i = 0; i< 10; i++) {printf("%d ", *(p + i));
}
free(p); // 释放
p = NULL;
return 0;
}
// 输出结果：0 0 0 0 0 0 0 0 0 0 void* realloc (void* ptr, size_t size);使用 realloc 再次申请分配内存的时候，需要指定重新开辟内存的字节总大小。假设我们之前使用 malloc / calloc 申请内存时，内存不够用了，realloc 就会派上用场。它可以做到很人性化地开辟内存。
情况①：当 malloc / calloc 申请的内存后面，有足够的空间再次扩充，realloc 就能够直接接着上次的位置，继续开辟。最终还是返回上一次开辟的原地址。
情况②：当 malloc / calloc 申请的内存后面，没有足够的空间再次扩充，realloc 也能够另起一块内存区域，将之前申请的内存中的数据也一并放入到新的内存区域中。此时最终返回的是新的地址。
使用示例#include#includeint main() {int* p = (int*) malloc(40); // 1
if (p == NULL) {perror("malloc");
return 1;
}
for (int i = 0; i< 10; i++) {*(p + i) = i;
}
int* ptr = (int*)realloc(p, 80); // 2
if (ptr != NULL) { // 3
p = ptr;
}
free(p); // 4
p = NULL;
return 0;
} // 1. malloc 申请分配内存。
// 2. 假设空间不够，使用 realloc 再次申请。
// 3. 由于内存有限，所以 realloc 也有可能申请内存失败，当失败的时候就会返回 NULL. 只有当 ptr 不为空的时候，才能够放入 p 中，这样就能保证 p 不受影响。
// 4. 释放内存
4. 注意事项申请内存分配后，始终需要记得使用 free. 当我们不释放动态申请的内存的时候，如果程序结束，动态申请的内存由操作系统自动回收；但如果程序不结束，动态内存是不会自动回收的，就会形成内存泄露的问题，久而久之，内存就会被 " 耗干 "。
虽然现在的操作系统很智能，能够限制一些程序的内存使用，但还是建议标准化。
二、动态内存管理函数使用时的错误示范 程序清单1动态内存申请失败，对 NULL 直接进行了解引用操作。
#include#include#includeint main () {int* p = malloc(INT_MAX); // 申请失败
*p = 100; // error
free(p);
p = NULL;
return 0;
} 对动态开辟空间的越界访问。
#include#includeint main() {int* p = malloc(40); // 开辟 40 个字节的内存
if (p == NULL) {perror("malloc");
return 1;
}
// 越界访问 41 ~ 44
for (int i = 0; i< 11; i++) {*(p + i) = i;
}
free(p);
p = NULL;
return 0;
} 对非动态开辟内存使用 free 释放.
#include#includeint main() {int a = 10;
int* p = &a;
free(p); // error
p = NULL;
return 0;
} free 释放不完整，或者 free 函数接收的指针不处于内存开辟的头部。
#include#includeint main() {int* p = (int*) malloc(100);
if (p == NULL) {perror("malloc");
return 1;
}
for (int i = 0; i< 10; i++) {*p = i;
p++;
}
free(p); // error
p = NULL;
return 0;
} 从第 40 个字节后面开始释放内存，那么前面的内存就未被释放完。
对同一块动态内存多次释放。
#include#includeint main() {int* p = malloc(100);
if (p == NULL) {perror("malloc");
return 1;
}
free(p);
free(p); // error
p = NULL;
return 0;
} 内存泄漏。
如下程序，在 test 函数中，即使我们写了 free，但最终走不到释放的代码，依然会存在内存泄漏的问题。所以说，free 代码的放置位置很关键，并不是写了 free 就一定能够释放动态内存。
#include#includevoid test() {int* p = (int*)malloc(100);
if (1) {return;
}
free(p); // 代码走不到这一行
p = NULL;
}
int main() {test();
return 0;
} #include#include#includevoid getMemory(char* p)
{p = (char*) malloc(100);
}
int main() {char* str = NULL;
getMemory(str);
strcpy(str, "hello world"); // 对空指针解引用
printf(str);
return 0;
} 分析：
在 getMemory 函数中，在堆区申请了 100 个字节的内存大小，之后我们可以通过指针 p 来找到这些内存。然而，在主函数中，str 始终为 NULL. 也就是说，str 并没有指向任何一块区域，所以后面在使用 strcpy 函数的时候，" hello world " 就不能成功拷贝。
这题错误的主要原因就是 str 为实参，p 为形参，对形参的操作不影响实参。
#include#include#includevoid getMemory(char** p, int num)
{*p = (char*) malloc(num); // 相当于 str 指向了开辟的 100 个字节的空间
// *(&str)<==>str = (char*) malloc(100);
}
int main() {char* str = NULL;
getMemory(&str, 100);
strcpy(str, "hello");
printf(str);
free(str);
str = NULL;
return 0;
}
// 输出结果： hello 分析：
程序清单2 算是 对 程序清单1 的优化，在 getMemory 函数中，当我们传过去的是 str 的地址时，再次对二级指针解引用，就相当于能够通过 str 直接找到开辟的内存。上面的程序没有问题，但是我们也不要忘记 free 来帮助系统回收内存了。
#include#include#includechar* getMemory()
{char p[] = "hello world";
return p;
}
int main() {char* str = NULL;
str = getMemory();
printf(str);
return 0;
}
// 输出结果：随机值 分析：
数组 p 在栈区开辟了内存，但出了 getMemory 函数后，数组中之前所占用的空间就被操作系统销毁了，也就是说，刚刚栈区的内存还给了系统，现在出了函数后，即使知道这块内存的地址，但已经没有权限再次使用这块区域了。因为数组 p 是一个临时的局部变量。
p 表示数组的首元素地址，假设 p 的地址为 0x11223344，那么出了 getMemory 函数后，现在 0x11223344 指向的内存可能已经被其他数据占用了。所以在主函数中，当 str 再次指向 0x11223344，找到的就是一些随机存放的数据。
#includeint* test() {int a = 10;
return &a;
// 出了 test 函数，a 的地址将被系统回收
}
int main() {int* p = test();
return 0;
} 程序清单4 和 程序清单3 的错误思想基本相同，这是典型的 【返回栈空间地址、野指针】的问题。a 的地址出了 test 函数后，就需要被回收，所以后续在主函数中，指针 p 就没有权限去操作这块内存区域。
为什么栈区的地址最后需要被回收？
答：因为函数和局部变量在使用时，需要在栈区开辟内存，当用完了，如果不被回收，那么操作系统的内存迟早要被耗尽。
举个例子：这就和住酒店一样，当 旅客 A 租完了房子，房子就需要打扫干净，腾出来给后面的 旅客B / 旅客C / 旅客D… 使用。否则，房子永远不够后面的旅客使用。如果 旅客A 前脚刚走，旅客B 就住进去了，那么这个房子暂时属于 旅客B 的，假设 旅客A 发现自己手机留在了刚刚的房子忘拿了，那么 旅客A 就需要和前台报备一下，如果 旅客A 直接冲进去了刚刚的房子找手机，旅客B 就会告他非法访问。
程序清单5#includevoid test(){char* str = (char*) malloc(100);
strcpy(str, "hello");
free(str);
if (str != NULL){
// 野指针，非法操作
strcpy(str, "world");
printf(str);
}
}
int main() {test();
return 0;
} 上面的代码依旧是野指针问题，当 malloc 开辟的堆区内存区域被 free 回收之后，str 指向的地址依旧是刚刚申请的头部地址，但此时却没有了操作这块内存的权限。所以将 " world " 字符串放入 str 指向的区域，最终就会造成非法访问。
综上所述，我们应该在 free 的后面添加如下代码：
str = NULL; // 防止 str 成为一个野指针你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧