动态内存分配与管理：malloc、calloc、realloc详解-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_42418315/article/details/132392789

动态内存分配

struct S arr[50];//50个struct S 类型的数据
我们已经掌握的内存开辟方式有：
int val=20;//在栈空间上开辟四个字节
char arr[10]={0};//在栈空间上开辟10个字节的连续空间
1、空间开辟大小是固定的
2、数组再声明的时候，必须指定数组的长度，它所需要的内存在编译时分配。
malloc和free、calloc、realloc

void* malloc(size_t size)
这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
如果开辟成功，则返回有一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要检查
返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定
如果参数size为0，malloc的行为是未定义的，取决于编译器。

void free(void* ptr)
free函数用来释放动态开辟的内存
如果参数指向的空间不是动态开辟的，free函数的行为是未定义的。
如果参数是NULL指针，则函数什么事都不做
malloc和free声明都在stdlib.h头文件中

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<errno.h>
int main()
{
        //向内存申请10个整型的空间
        int* p = (int*)malloc(10 * sizeof(int));
        //int* p = (int*)malloc(INT_MAX);
        if (p == NULL)
        {
               //打印错误原因的一个方式
               printf("%s\n", strerror(errno));
        }
        else
        {
               //正常使用
               int i = 0;
               for (i = 0; i < 10; i++)
               {
                       *(p + i) = i;
               }
               for (i = 0; i < 10; i++)
               {
                       printf("%d", *(p + i));
               }
        }
        //当动态申请的空间不再使用的时候，就应该还给操作系统
        free(p);
        p = NULL;
}

void* calloc(size_t num,size_t size)
函数的功能是为num个大小为size的元素开辟一片空间，并且把空间的每个字节初始化为0

int main()
{
        //向内存申请10个整型的空间
        int* p = (int*)calloc(10, sizeof(int));//初始化每个元素为0
        if (p == NULL)
        {
               //打印错误原因的一个方式
               printf("%s\n", strerror(errno));
        }
        else
        {
               //正常使用

               for (i = 0; i < 10; i++)
               {
                       printf("%d", *(p + i));
               }
        }
        //当动态申请的空间不再使用的时候，就应该还给操作系统
        free(p);
        p = NULL;
}

realloc 调整动态开辟内存大小
void* realloc（void* ptr，size）
ptr 要调整的内存地址 size 调整之后的新大小返回值为调整之后的内存起始位置
//就是使用malloc开辟的20个字节空间
//假设20个字节不能满足需要，希望能有40个空间，使用realloc调整动态开辟的内存
//1、如果p指向的空间之后有足够的内存空间可以追加，则直接追加，后返回p
//2、如果p指向的空间之后没有足够的内存空间可以追加，则realloc函数会重新找一个新的内存区域，开辟一块满足需求的空间，并把原来内存中的数据拷贝过去，释放旧的内存空间，返回新开辟的内存空间地址
//3、得用一个新的变量来接受realloc函数的返回值

int main()
{
        int* p = (int*)malloc(20);
        int* p=realloc(NULL,40);//malloc(40)
        if (p == NULL)
        {
               printf("%s\n", strerror(errno));
        }
        else
        {
               int i = 0;
               for (i = 0; i < 5; i++)
               {
                       *(p + i) = i;
               }
        }
        int* ptr = realloc(p, 4000);
        if (ptr != NULL)//开辟成功
        {
               p = ptr;
               int i = 0;
               for (i = 5; i < 10; i++)
               {
                       *(p + i) = i;
               }
               for (i = 0; i < 10; i++)
               {
                       printf("%d ", *(p + i));
               }
        }
        //释放内存
        free(p);
        p = NULL;
}

常见动态内存错误：

1、对空指针的解引用操作

int main()
{
        //1、对空指针进行解引用操作
        int* p = (int*)malloc(40);
        //万一malloc失败了，p就被赋值为NULL
        *p = 0;//err
        int i = 0;
        for (i = 0; i < 10; i++)
        {
               *(p + i) = i;//err
        }
        free(p);
        p = NULL;
}

2、对动态开辟的内存的越界访问

        //2、对动态开辟的内存的越界访问
        int* p = malloc(5 * sizeof(int));
        if (p == NULL)
        {
               return 0;
        }
        else
        {
               int i = 0;
               for (i = 0; i < 10; i++)//err
               {
                       *(p + i) = i;
               }
        }
        free(p);
        p = NULL;

3、对非动态开辟内存使用free释放

        //3、对非动态开辟内存使用free释放
        int a = 10;
        int* p = &a;
        *p = 20;
        free(p);//err
        p = NULL;

4、使用free释放动态内存的一部分

        //4、使用free释放动态内存的一部分
        int* p = (int*)malloc(40);
        if (p == NULL)
        {
               return 0;
        }
        int i = 0;
        for (i = 0; i < 10; i++)
        {
               *p++ = i;//p发生变化，p不是指向起始位置，就是释放内存的一部分
        }
        //回收空间
        free(p);//从p地址开始释放空间 err
        p = NULL;
}

5、对同一块内存多次释放

        //5、对同一块内存多次释放
        int* p = (int*)malloc(40);
        if (p == NULL)
        {
               return 0;
        }
        //使用
        //释放
        free(p);
        p = NULL;//只要p为空指针，后面的free不起作用
        free(p);//err
}

6、动态开辟的内存忘记释放（内存泄漏）

        //6、动态开辟的内存忘记释放（内存泄漏）
        while (1)
        {
               malloc(1);//一直开辟空间
        }

面试题：

void GetMemory(char* p)
{
        p = (char*)malloc(100);
}
void Test(void)
{
        char* str = NULL;
        GetMemory(str);
        strcpy(str, "hello");//str没有指向一块空间，不能拷贝
        printf(str);
}
int main()
{
        Test();
}

存在的问题：
1、运行代码会出现崩溃的现象
2、程序存在内存泄漏的问题
str以值传递的形式给p,p是GetMemory函数的形参，只能在函数内部有效，等GetMemory函数返回之后，动态开辟内存尚未释放，并且无法找到，所以会造成内存泄漏

修改1：

void GetMemory(char** p)
{
        *p = (char*)malloc(100);
}
void Test(void)
{
        char* str = NULL;
        GetMemory(&str);
        strcpy(str, "hello");//str没有指向一块空间，不能拷贝
        printf(str);
        free(str);
        str = NULL;
}
int main()
{
        Test();
}

修改2：

char* GetMemory(char* p)
{
        p = (char*)malloc(100);//堆区
        return p;
}
void Test(void)
{
        char* str = NULL;
        str=GetMemory(str);
        strcpy(str, "hello");//str没有指向一块空间，不能拷贝
        printf(str);
        free(str);
        str = NULL;
}
int main()
{
        Test();
}

char* GetMemory()
{
        static char p[] = "hello world";//局部变量在栈区 static静态区
        return p;//返回栈空间地址的问题
}
void Test(void)
{
        char* str = NULL;
        str=GetMemory(str);
        printf(str);
}
int main()
{
        Test();
}

int* test()
{
        int a = 10;//栈区
        return &a;//返回栈区地址
}
int main()
{
        int* p=test();
        *p = 20;//有人接收函数返回地址，造成非法访问
}

int* f2(void)
{
        int* ptr;//没有初始化，是个随机数 野指针
        *ptr = 10;//非法访问
        return ptr;
}

void* GetMemory(char**p,int num)
{
        *p = (char*)malloc(num);//没有释放空间
}
void Test(void)
{
        char* str = NULL;
        GetMemory(&str,100);
        strcpy(str, "hello");
        printf(str);
        //修改
        free(str);
        str = NULL;
}
int main()
{
        Test();
}

void Test(void)
{
        char* str = (char*)malloc(100);
        strcpy(str, "hello");
        free(str);//已经释放空间，str属于野指针，其后属于非法访问
        //修改
        str = NULL;//不会进入下面语句
        if (str != NULL)//free释放str指向的空间后，并不会把str置为NULL，只是将指针地址放到原始地址
        {
               strcpy(str, "world");//覆盖hello
               printf(str);
        }
}
int main()
{
        Test();
}

1、栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量，函数参数，返回数据，返回地址等。
2、堆区（heap）：一般由程序员分配释放，若程序员不释放，程序结束时可能有OS回收。分配方式类似于链表。
3、数据段（静态区）（static）：存放全局变量，静态数据。程序结束后由系统释放。
4、代码段：存放函数体（类成员函数和全局函数）的二进制代码
在这里插入图片描述
柔性数组
特点：1、结构中的柔性数组成员前面必须至少一个其他成员
2、sizeof返回的这种结构大小不包括柔性数组的内存
3、包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
方法一：

struct S
{
        int n;

        //int arr[];
        int arr[0];//未知大小的-柔性数组成员-数组的大小是可以调整的
};
int main()
{
        //struct S s;
        //printf("%d\n", sizeof(s));//4
        struct S* ps = (struct S*)malloc(sizeof(struct S) + 5 * sizeof(int));
        ps->n = 100;//4字节
        int i = 0;
        for (i = 0; i < 5; i++)
        {
               ps->arr[i] = i;
        }
        struct S* ptr = realloc(ps, 44);
        if (ptr != NULL)
        {
               ps = ptr;
        }
        for (i = 5; i < 10; i++)
        {
               ps->arr[i] = i;
        }
        for (i = 0; i < 10; i++)
        {
               printf("%d\n", ps->arr[i]);
        }
        //释放
        free(ps);
        ps = NULL;
}

方法二：

struct S
{
        int n;
        int* arr;//指针变量存放地址
};
int main()
{
        //struct S s;
        //printf("%d\n", sizeof(s));//8
        int i = 0;
        struct S* p = (struct S*)malloc(sizeof(struct S));
        p->n = 100;
        p->arr = (int*)malloc(5 * sizeof(int));//malloc返回地址
        for (i = 0; i < 5; i++)
        {
               p->arr[i] = i;
        }
        for(i = 0; i < 5; i++)
        {
               printf("%d\n", p->arr[i]);
        }
        //调整大小
        int* ptr = realloc(p->arr, 10 * sizeof(int));
        if (ptr != NULL)
        {
               p->arr = ptr;
        }
        for (i = 5; i < 10; i++)
        {
               p->arr[i] = i;
        }
        for (i = 0; i < 10; i++)
        {
               printf("%d\n", p->arr[i]);
        }
        //释放内存空间 注意释放顺序
        free(p->arr);
        p->arr = NULL;
        free(p);
        p = NULL;
}

方法一和方法二完成同样的功能，方法一好处：1、方便内存释放，将结构体的内存以及其成员一次性分配好，并返回给用户一个结构体指针，用户做一次free就把所有内存释放掉，而方法二做了两次内存分配，并把整个结构体返回给用户，用户需要先释放结构体成员的空间，再释放结构体。2、有利于访问速度，连续的内存有利于提高访问速度，也有利于减少内存碎片（malloc用的越多，内存碎片越多）（malloc用的越多，越不连续，整体效率低）
在这里插入图片描述

C语言知识（3）

动态内存分配