首页 > 操作系统 >

C语言系列（五）的内存分配和释放

电脑杂谈　发布时间：2020-04-06 05:00:38　来源：网络整理

malloc calloc realloc_calloc 释放_c calloc

本文来自: [徐H的CSDN博客]

首先让我们看一下科学普及:

1. 什么是堆: 堆是每个人共享的空间，分为全局堆和局部堆. 全局堆是所有未分配的空间，本地堆是用户分配的空间. 操作系统初始化进程时分配堆. 您还可以在操作过程中向系统询问额外的堆，但请记住在用完后将其返回给操作系统，否则将导致内存泄漏.

2. 什么是堆栈: 堆栈是线程唯一的，并保存其运行状态和局部自动变量. 堆栈程的开头初始化，并且每个线程的堆栈彼此独立. 每个函数都有自己的堆栈，用于在函数之间传递参数. 切换线程时，即切换SS / ESP寄存器，操作系统将自动切换堆栈. 堆栈空间不需要使用高级语言进行显式分配和取消分配.

栗子:

int a=0;        //全局初始化区
char *p1;       //全局未初始化区
void main()
{
   int b;          //栈
   char s[]="bb";  //栈
   char *p2;       //栈
   char *p3="123"; //其中，“123\0”常量区，p3在栈区
   static int c=0; //全局区
   p1=(char*)malloc(10);   //10个字节区域在堆区
   strcpy(p1,"123");    //"123\0"在常量区，编译器 可能 会优化为和p3的指向同一块区域
}

堆栈内存

void stackFun(){
    int a[1024];
    //栈内存自动释放
}

c calloc_calloc 释放_malloc calloc realloc

堆内存

void heapFun(){
    //40M内存
    //字节
    //void *任意类型的指针
    int* p = malloc(1024 * 1024 * 10 * sizeof(int));
    //释放
    free(p);
}

void main(){    
    //在堆内存上，分配40M的内存
    while (1){
        Sleep(1000);    
        stackFun();
    }
    getchar();
}

创建一个数组并动态指定数组的大小（您可以释放指定大小的内存，以便在程序运行时间过长时使用，这等效于Java中的集合）

静态内存分配时calloc 释放，分配的内存大小是固定的，问题是: 1.很容易超过堆栈内存的最大值. 2.为了防止内存不足会打开更多的内存，容易浪费记忆

动态内存分配，在程序运行期间，动态指定要使用的内存大小，手动释放，释放这些内存后可以重新使用（活水）

功能: calloc（）分配内存空间并初始化

calloc（）函数用于动态分配内存空间并将其初始化为0. 其原型为:

  void* calloc (size_t num, size_t size);

c calloc_malloc calloc realloc_calloc 释放

calloc（）在内存中动态分配num个连续的大小长度的空间，并将每个字节初始化为0. 因此，结果是分配了num * size个内存空间字节，每个字节的值为0.

【返回值】如果分配成功，将返回指向内存的地址. 如果失败，将返回NULL.

功能: malloc（）动态分配内存空间

malloc（）函数用于动态分配内存空间（如果您不了解动态内存分配，请检查: C语言动态内存分配和变量存储类别），其原型为:

void* malloc (size_t size);

程序中应用程序的代码如下:

void main(){
    //静态内存分配创建数组，数组的大小是固定的
    //int i = 10;
    //int a[i];
    int len;
    printf("输入数组的长度：");
    scanf("%d",&len);
    //开辟内存，大小len*4字节
    int* p = malloc(len * sizeof(int));
    //p是数组的首地址，p就是数组的名称
    //给数组元素赋值（使用这一块刚刚开辟出来的内存区域）
    int i = 0;
    for (; i < len - 1; i++){
        p[i] = rand() % 100;
        printf("%d,%#x\n", p[i], &p[i]);
    }
    //手动释放内存 
    //free()释放动态分配的内存空间
    free(p);
    getchar();
}

realloc重新分配内存

c calloc_calloc 释放_malloc calloc realloc

void main(){
    int len;
    printf("第一次输入数组的长度：");
    scanf("%d", &len);
    //int* p = malloc(len * sizeof(int)); 
    int* p = calloc(len, sizeof(int));
    int i = 0;
    for (; i < len; i++){
        p[i] = rand() % 100;
        printf("%d,%#x\n", p[i], &p[i]);
    }
    int addLen;
    printf("输入数组增加的长度：");
    scanf("%d", &addLen);
    //内存不够用，扩大刚刚分配的内存空间
    //1.原来内存的指针 2.内存扩大之后的总大小 
    int* p2 = realloc(p, sizeof(int) * (len + addLen));
    if (p2 == NULL){
        printf("重新分配失败，世界那么大，容不下我。。。");
    }

//缩小，部分数据将丢失

//展开，（连续）

1. 如果当前内存段后面有所需的内存空间，则直接扩展该内存空间，realloc返回原始指针

2. 如果当前内存段后面的可用字节不足，则使用堆中可以满足此要求的第一个内存块，将当前数据复制到新位置calloc 释放，然后释放原始，关闭并返回到新的内存地址

3. 如果应用程序失败，则返回NULL，并且原始指针仍然有效

//接着上面的代码重新赋值
    i = 0;
    printf("--------------------------\n");
    for (; i < len + addLen; i++){
        p2[i] = rand() % 200;
        printf("%d,%#x\n", p2[i], &p2[i]);
    }
    //手动释放内存
    if (p != NULL){
        free(p);
        p = NULL;
    }   
    if (p2 != NULL){
        free(p2);
        p2 = NULL;
    }
    getchar();
}

1. 无法多次释放；

malloc calloc realloc_calloc 释放_c calloc

2. 释放后（指针仍然具有值），将指针设置为NULL以标记释放已完成；

3. 内存泄漏（在重新分配p之后，然后释放它，并且内存并未真正释放）；

void main(){
    int len;
    printf("输入数组的长度：");
    scanf("%d", &len);
    int* p = malloc(len * sizeof(int));     
    int i = 0;
    for (; i < len; i++){
        p[i] = rand() % 100;
        printf("%d,%#x\n", p[i], &p[i]);
    }
    if (p != NULL){
        free(p);
        p = NULL;
    }
    getchar();
}