C语言深入学习 --- 5.动态内存管理

子期每天敲代码2024-03-09 20:58

文章目录

第五章 动态内存管理

1.存在动态内存分配的意义

2.动态内存函数

  • malloc

  • free

  • calloc

  • realloc

3.常见的动态内存错误

4.经典笔试题

5.C/C++程序的内存开辟

6.柔性数组

1.存在动态内存分配的意义

c 复制代码 
    int x = 5; //在栈空间中开辟了大小为4个字节的空间
    char arr[5] = { 0 }; //在栈空间上开辟了5个连续的字节空间。

以上开辟空间的方式有两个特点：

1.空间开辟的大小是固定的。

2.数组在声明的时候，必须要指定数组的长度，编译时分配所需要的内存空间。

有时候需要的空间大小在程序运行后才知道，以上的开辟空间方式就不能满足了。

2.动态内存函数

2.1 malloc和free

动态内存开辟函数：

c 复制代码 
void* malloc (size_t size);

该函数会向内存申请一块连续可用的空间，并返回指向该空间的指针。

开辟成功，则返回一个指向开辟好的空间的指针。

开辟失败，则返回一个NULL指针。

返回值类型为void*，malloc函数不知道要开辟什么类型的空间，在使用的时候要自己决定。

size为0时，malloc的行为是标准是未定义的，取决编译器。

动态内存的释放和回收函数：

c 复制代码 
void free (void* ptr)

用来释放动态开辟的内存。

参数ptr所指向的空间不是动态开辟的，那么free函数的行为是未定义的。

参数ptr是NULL指针的话，则函数什么都不做。

c 复制代码 
#include <stdio.h>
#include <stdlib.h>

int main()
{
    //1
    int num = 0;
    scanf("%d", &num);
    int arr[num] = { 0 };
    //2
    int* ptr = NULL;
    ptr = (int*)malloc(num * sizeof(int));
    if (ptr != NULL)
    {
        int i = 0;
        for (i = 0; i < num; i++)
        {
            *(ptr + i) = 0;
        }
    }
    free(ptr);
    ptr = NULL;
    return 0;
}
2.2 calloc

calloc也可以用来进行动态内存分配。

c 复制代码 
void* calloc (size_t num, size_t size);

num个大小为size的元素开辟一块空间，并把空间每个字节都初始化为0。

与malloc不同的是calloc会在返回地址之前把申请的空间都初始化为0。

c 复制代码 
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int* p = (int*)calloc(5, sizeof(int));
    if (p != NULL)
    {
        //使用空间
    }
    free(p);
    p = NULL;
    return 0;
}

如果对申请的空间需要初始化，可以使用calloc函数来完成。

2.3 realloc

realloc函数让动态内存管理更加灵活。

有时申请的空间太小了又或者太大了，为了合理的分配内存，需要对内存的大小做灵活的调整。realloc函数就可以对动态开辟内存大小进行调整。

c 复制代码 
void* realloc (void* ptr, size_t size);

  • ptr为需要调整的内存地址。

  • size为调整之后的新大小。

  • 返回值为调整后的内存起始位。

  • 该函数调整原函数内存空间大小的基础上，还会把原来内存中数据移动到新的空间。

  • realloc在调整空间时存在两种情况：

1.原有空间之后有足够大的空间，要扩展内存就直接在原在内存之后追加空间，原先空间的数据不会发生变化。

2.原有空间之后没有足够大的空间时，扩展内存就会在堆空间上另外找一个大小合适的连续空间使用。函数返回的是新的内存地址。

c 复制代码 
#include <stdio.h>
#include <stdlib.h>

int main()
{
    //1
    int* ptr = (int*)malloc(100);
    if (ptr != NULL)
    {

    }
    else
    {
        perror(main);
    }
    ptr = realloc(ptr, 1000);


    //2
    int* p = NULL;
    p = (int* )realloc(ptr,1000);
    if (p != NULL)
    {
        ptr = p;
    }
    else
    {
        perror(main);
    }
    free(ptr);
    ptr = NULL;
    return 0;
}

3.常见的动态内存错误

3.1 对NULL指针的解引用操作
c 复制代码 
int main()
{
    int* p = (int*)malloc(INT_MAX/ 2);
    *p = 10; //如果p的值为NULL,会出现问题。
    free(p);
    p = NULL;
    return 0;
}
3.2 对动态开辟空间的越界访问
c 复制代码 
int main()
{
    int i = 0;
    int* p = (int*)malloc(10 * sizeof(int));
    if (p == NULL)
    {
        return;
    }
    for (i = 0; i <= 10; i++)
    {
        *(p + i) = i; //到i=10时，会出现越界访问的问题。
    }
    free(p);
    p = NULL;
    return 0;
}
3.3 对非动态开辟内存使用free释放
c 复制代码 
int main()
{
    int a = 10;
    int* p = &a;
    free(p);  //这种做法是错误的，
    return 0;
}
3.4 使用free释放一块内存开辟内存的一部分
c 复制代码 
int main()
{
    int* p = (int*)malloc(10);
    p++;
    free(p); //此时p不再指向初始地址.
    return 0 ;
}
3.5 对同一块动态内存多次释放
c 复制代码 
int main()
{
    int* p = (int*)malloc(10);
    free(p);
    free(p); //重复释放
    return 0;
}
3.6 动态开辟内存忘记释放(内存泄漏)
c 复制代码 
void test()
{
    int* p = (int*)malloc(100);
    if (p != NULL)
    {
        *p = 10;
    }
}

int main()
{
    test();
    return 0;
}

忘记释放不再使用的动态开辟的空间会造成内存泄漏。

动态开辟的空间一定要释放，且正确释放。

4.经典题

4.1 题1：
c 复制代码 
void GetMemory(char *p)
{
 p = (char *)malloc(100);
}

void Test(void)
{
 char *str = NULL;
 GetMemory(str);
 strcpy(str, "hello world");
 printf(str);
}

int main()
{
    Test();
    return 0;
}

结果：崩溃

4.2 题2：
c 复制代码 
char *GetMemory(void)
{
 char p[] = "hello world";
 return p;
}

void Test(void)
{
 char *str = NULL;
 str = GetMemory();
 printf(str);
}

int main()
{
    Test();
    return 0;
}

结果：随机值

4.3 题3：
c 复制代码 
void GetMemory(char** p, int num)
{
    *p = (char*)malloc(num);
}

void Test(void)
{
    char* str = NULL;
    GetMemory(&str, 100);
    strcpy(str, "hello");
    printf(str);
}


int main()
{
    Test();
    return 0;
}

结果：hello

4.4 题4：
c 复制代码 
void Test(void)
{
    char* str = (char*)malloc(100);
    strcpy(str, "hello");
    free(str);
    if (str != NULL)
    {
        strcpy(str, "world");
        printf(str);
    }
}

int main()
{
    Test();
    return 0;
}

结果：world

5.C/C++程序的内存开辟

C/C++程序内存分配的几个区域：

  1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

  2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。

  3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。

  4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁。

所以生命周期变长。

6.柔性数组

在C99中，结构中最后一个元素允许是未知大小的数组，这就叫做【柔性数组】成员。

c 复制代码 
struct S
{
    int a;
    int arr[0];  //柔性数组成员
};

部分编译器会报错可改成：

c 复制代码 
struct S
{
    int a;
    int arr[];  //柔性数组成员
};
6.1 柔性数组的特点

  • 结构中柔性数组成员前面必须至少一个其他成员。

  • sizeof返回的结构大小不包括柔性数组的内存。

  • 包含柔性数组的结构需要使用malloc函数进行内存的动态分配，且分配的内存该大于结构的大小，以适应柔性数组的预期大小。

c 复制代码 
typedef struct s_ct
{
    int a;
    int arr[0];
}ct_a;

int main()
{
    printf("%d\n", sizeof(ct_a));  //通过以上的描述，可以知道这里输出的是4.
    return 0;
}
6.2 柔性数组的使用
c 复制代码 
typedef struct s_ct
{
    int a;
    int arr[0];
}ct_a;

int main()
{
    ct_a* p = (ct_a*)malloc(sizeof(ct_a) + 10*sizeof(int));
    p->a = 10;
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        p->arr[i] = i;
    }
    free(p);
    p = NULL;
    return 0;
}

这里的柔性数组a，相当获得了10个整型元素的连续空间。

6.3 柔性数组的优势

6.2中的代码还可以这样写：

c 复制代码 
typedef struct s_ct
{
    int a;
    int *pa;
}ct_a;

int main()
{
    ct_a* p = (ct_a*)malloc(sizeof(ct_a));
    p->a = 10;
    p->pa = (ct_a*)malloc(p->a * sizeof(int));
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        p->pa[i] = i;
    }
    free(p->pa);
    p->pa = NULL;
    free(p);
    p = NULL;
    return 0;
}

6.2和6.3的代码可以实现相同的功能，但6.2的方法更好。

原因：

1.方便内存释放

如果把结构体的内存及成员的内存一次性分配好，并返回一个结构体指针，那么只需要做一次free就可以把内存释放掉。是给别人使用的函数中，在里面做二次分配，他人可以通过free释放，但不知道该结构体内的成员也需要free释放。

2.有利于访问速度

连续的内存有利于提高访问的速度，也有利于减少内存碎片。

练习：

1.模拟实现atoi

c 复制代码 
#include <stdio.h>
#include <limits.h>
#include <ctype.h>

enum State
{
    INVALID,
    VALID
};

enum State state = INVALID;

int my_atoi(const char* p)
{
    int flag = 1;
    if (p == NULL)
    {
        return 0;
    }
    if (*p == '\0')
    {
        return 0;
    }
    while (isspace(*p))
    {
        p++;
    }
    if (*p == '+')
    {
        flag = 1;
        p++;
    }
    else if (*p == '-')
    {
        flag = -1;
        p++;
    }

    long long n = 0;
    while (isdigit(*p))
    {
        n = n * 10 + flag * (*p - '0');
        if (n < INT_MIN || n>INT_MAX)
        {
            return 0;
        }
        p++;
    }
    if (*p == '\0')
    {
        state = VALID;
        return (int)n;
    }
    else
    {
        return (int)n;
    }
}

int main()
{
    const char* p = "   -14a";
    int ret = my_atoi(p);
    if(state == VALID)
        printf("合法：%d\n", ret);
    else
        printf("非法：%d\n", ret);
    return 0;
}

2.一个数组中只有两个数组出现了一次，其他所有数字都出现两次。编写一个函数找出这两个只出现一次的数字。

c 复制代码 
#include <stdio.h>

void Find(int arr[], int sz, int* x1, int* y1)
{
    int i = 0;
    int ret = 0;
    for (i = 0; i < sz; i++)
    {
        ret ^= arr[i];
    }
    int Pos = 0;
    for (i = 0; i < 32; i++)
    {
        if (((ret >> i) & 1) == 1)
        {
            Pos = i;
            break;
        }
    }

    int num1 = 0;
    int num2 = 0;
    for (i = 0; i < sz; i++)
    {
        if (((arr[i] >> Pos) & 1) == 1)
        {
            num1 ^= arr[i];
        }
        else
        {
            num2 ^= arr[i];
        }
    }
    *x1 = num1;
    *y1 = num2;
}

int main()
{
    int arr[] = { 1,2,3,4,5,6,1,2,3,4 };
    int x = 0;
    int y = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);
    Find(arr, sz, &x, &y);

    printf("%d %d",x, y);
    return 0;
}

上一章：C语言深入学习 --- 4.自定义类型(结构体+枚举+联合)

配套练习：

C语言练习题110例(一)
C语言练习题110例(二）
C语言练习题110例(三)
C语言练习题110例(四)
C语言练习题110例(五)
C语言练习题110例(六)
C语言练习题110例(七)
C语言练习题110例(八)
C语言练习题110例(九)
C语言练习题110例(十)
C语言练习题110例(十一)

相关推荐
pianmian11 分钟前
贪心算法.
算法·贪心算法
chenziang11 小时前
leetcode hot 100 二叉搜索
数据结构·算法·leetcode
single5942 小时前
【c++笔试强训】（第四十五篇）
java·开发语言·数据结构·c++·算法
一棵开花的树，枝芽无限靠近你3 小时前
【PPTist】表格功能
前端·笔记·学习·编辑器·ppt·pptist
呆头鹅AI工作室3 小时前
基于特征工程（pca分析）、小波去噪以及数据增强，同时采用基于注意力机制的BiLSTM、随机森林、ARIMA模型进行序列数据预测
人工智能·深度学习·神经网络·算法·随机森林·回归
一勺汤4 小时前
YOLO11改进-注意力-引入自调制特征聚合模块SMFA
人工智能·深度学习·算法·yolo·目标检测·计算机视觉·目标跟踪
yuwinter4 小时前
鸿蒙HarmonyOS学习笔记（8）
笔记·学习
每天写点bug4 小时前
【golang】map遍历注意事项
开发语言·算法·golang
程序员JerrySUN4 小时前
BitBake 执行流程深度解析：从理论到实践
linux·开发语言·嵌入式硬件·算法·架构
Ricciflows4 小时前
MIT线性代数教材：Linear Algebra and Its Applications
人工智能·学习·线性代数·机器学习·数学建模·矩阵
热门推荐
01Gitlab ci/cd02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03玄机平台应急响应—webshell查杀04新手学习VR全景需要知道的几个问题05优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间06HCIA-datacom数通题库和录播视频资料07RAG 实践- Ollama+RagFlow 部署本地知识库08【一文读懂】NTN（非地面网络）技术介绍09支付宝短视频平台创作分成激励项目10docker安装启动问题解决排查