C语言中的内存动态管理

已于 2024-06-18 17:54:51 修改
阅读量751 收藏 33
点赞数 21
文章标签： c语言 开发语言
于 2024-06-18 17:54:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84421190/article/details/139751980
版权

1.为什么有动态内存管理

int a=20;//开辟4个字节

int arr[10]={0};//开辟40个字节

上述的代码有两个特点

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

2.数组在申明的时候已经固定了大小，无法更改。

 这样写代码不够灵活，所以c语言中引入了动态内存管理，让程序员可以自己申请和释放空间，这样可以灵活一点。

2.malloc和free

malloc和free的头文件均为stdlib.h

2.1malloc

一个动态内存开辟函数

void*malloc (size_t size)

malloc可以申请一片连续的空间，并返回开辟空间的首地址 。

1.开辟成功，返回这片连续空间的首地址。

2.开辟失败，返回NULL指针。例:INT_MAX

3.返回类型是void*，所以开辟空间的类型可以根据使用者自由决定。

4.size是字节数。

2.2free

free是用来释放和回收动态内存管理开辟的空间的。

void free （void*ptr）

1.如果ptr指向的空间不是动态开辟的，那么free的行为是未定义的

2.如果ptr是NULL，则函数什么都不做。

#include <stdio.h>
#include<stdlib.h>
int main()
{
	int* ptr = NULL;
	ptr = (int*)malloc(10 * sizeof(int));//开辟空间
	if (NULL != ptr)//判断ptr指针是否为空
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(ptr + i) = 0;
		}
	}
	free(ptr);//释放ptr所指向的动态内存
	ptr = NULL;
	return 0;
}

3.calloc和realloc 

3.1calloc

calloc也可以来开辟空间。

void* calloc (size_t num, size_t size);

calloc的功能为开辟num个大小为size的一块空间，并且把空间的每个字节都初始化为0.

 int main()
{
    //申请10个连续的整形空间；
    //malloc(10*sizeof(int))
    int* p = (int*)calloc(10, sizeof(int));
    if (p == NULL)
    {
        perror("calloc");
        return 1;
    }
    //使用
    for (int i = 0; i < 10; i++)
    {
        printf("%d ", p[i]);//打印出10个0。
    }

    //释放
    free(p);
    p = NULL;
    return 0;
}

 calloc和malloc没什么区别，只是calloc会把申请的字节都初始化为0.

3.2realloc

这个函数可以使我们开辟后的空间可以改变。

void* realloc (void* ptr, size_t size);

 ptr：要调整的内存地址

size：把该地址改为多大的空间

返回值为改变之后的起始地址

realloc函数在扩容空间的时候，扩容成功有两种情况

情况1.后面有充足的空间，把后面的空间直接分配给你。

情况2.后面的空间不足

1.直接在堆区找一块新的满足大小的空间

2.将旧的数据，拷贝到新的地址当中

3.将旧空间释放

4.返回新的地址

int main()
{
	//申请10个连续的整形空间；
	//malloc(10*sizeof(int))
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	//使用
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);
	}
	//调整为20个整形空间
	//用新的指针接收，这样开辟失败也不会丢失p指向的内容
	int* ptr = (int*)realloc(p, 20 * sizeof(int));
	if (ptr != NULL)
	{
		p = ptr;
	}
	//使用
	//。。。
	//释放
	free(p);
	p = NULL;
	return 0;
}

4.常见的动态内存的错误

4.1对NULL指针的解引用操作

就是没有开辟成功空间，返回NULL地址，又去解引用它。

int main()
{
    int* p = (int*)malloc(sizeof(INT_MAX));
    //使用
    *p = 10;
    //释放
    free(p);
    p = NULL;
    return 0;
}

4.2 对动态开辟空间的越界访问 

int main()
{
    //申请10个连续的整形空间；
    //malloc(10*sizeof(int))
    int* p = (int*)malloc(10*sizeof(int));
    if (p == NULL)
    {
        perror("malloc");
        return 1;
    }
    //使用
    for (int i = 0; i < 40; i++)
    {
        p[i] = i + 1;//越界访问
    }
    free(p);
    p = NULL;
    return 0;
}

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

int main()
{
    int a = 10;
    int* p = &a;
    free(p);
}

free释放的是动态内存的空间。

4.4 使用free释放一块动态开辟内存的一部分 

int main()
{
    //申请10个连续的整形空间；
    //malloc(10*sizeof(int))
    int* p = (int*)malloc(10*sizeof(int));
    if (p == NULL)
    {
        perror("malloc");
        return 1;
    }
    //使用
    for (int i = 0; i < 5; i++)
    {
        *(p++) = i + 1;
    }
    free(p);
    p = NULL;
    return 0;
}

 p的地址被改变了，释放的是一部分

4.5 对同一块动态内存多次释放

int main()
{
    //申请10个连续的整形空间；
    //malloc(10*sizeof(int))
    int* p = (int*)malloc(10 * sizeof(int));
    if (p == NULL)
    {
        perror("malloc");
        return 1;
    }
    //使用
    for (int i = 0; i < 5; i++)
    {
        *(p++) = i + 1;
    }
    free(p);//第一次
    //...
    free(p);//第二次
    p = NULL;
    return 0;
}

p释放了两次，第二次相当于释放野指针了，会发生错误。如果第一次释放p之后把它置为NULL，则不会发生错误，就是逻辑上说不通。

4.6 动态开辟内存忘记释放（内存泄漏 ）

void test()
{
    int* p = (int*)malloc(10 * sizeof(int));
    int flag = 1;
    if (p == NULL)
    {
        perror("malloc");
        return 0;
    }
    //使用...


    if (flag)
    {
        return 1;
    }
    free(p);
    p = NULL;
}
int main()
{
    test();
    return 0;
}

这个test函数就没有释放，提前return了

5.动态内存笔试题分析 

5.1对NULL解引用

void GetMemory(char* p)
{
    p = (char*)malloc(100);//p开辟了一片空间，但是和str没有关系

    //忘记free
}
void Test(void)
{
    char* str = NULL;
    GetMemory(str);//传值调用，非传址调用
    strcpy(str, "hello world");//对str进行解引用操作，程序会奔溃
    printf(str);//这个打印是没有问题的
}
int main()
{
    Test();
    return 0;
}

 这个代码有两个错误

1.对str进行解引用操作，程序会奔溃

2.开辟的空间没有释放，内存会泄露

正确写法1

void GetMemory(char** p)
{
    *p = (char*)malloc(100);
}
void Test(void)
{
    char* str = NULL;
    GetMemory(&str);
    strcpy(str, "hello world");
    printf(str);
    free(str);
    str = NULL;
}
int main()
{
    Test();
    return 0;
}

正确写法2

char* GetMemory(char* p)
{
    *p = (char*)malloc(100);
    return p;
}
void Test(void)
{
    char* str = NULL;
    str=GetMemory(&str);
    strcpy(str, "hello world");
    printf(str);
    free(str);
    str = NULL;
}
int main()
{
    Test();
    return 0;
} 

开辟的空间可以返回地址 

5.2返回栈空间地址的问题

char* GetMemory(void)
{
    char p[] = "hello world";
    return p;//返回指针，但是返回之后这个函数就销毁了，但是如果malloc开辟的空间就不会销毁，因为malloc释放的话得用free。
}
void Test(void)
{
    char* str = NULL;
    str = GetMemory();//str接收的是野指针，GetMemory不属于当前程序了
    printf(str);//打印的时候可能被别人修改了
}
int main()
{
    Test();

    return 0;
}

返回栈空间的时候，接收变量没有问题，但是接收地址有问题 ，因为会销毁。

 5.3 注意内存泄漏

void GetMemory(char** p, int num)
{
    *p = (char*)malloc(num);
}
void Test(void)
{
    char* str = NULL;
    GetMemory(&str, 100);
    strcpy(str, "hello");
    printf(str);//可以打印，但是malloc开辟的内存需要释放
}
int main()
{
    Test();
    return 0;
}

正确写法

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();
    return 0;
} 

 5.4非法访问

void Test(void)
{
    char* str = (char*)malloc(100);
    strcpy(str, "hello");
    free(str);//把malloc出来的空间还给操作系统，无法继续使用，str变为野指针
    if (str != NULL)//ok
    {
        strcpy(str, "world");//非法访问
        printf(str);
    }
}
int main()
{
    Test();
    return 0;
}

正确写法

void Test(void)
{
    char* str = (char*)malloc(100);
    strcpy(str, "hello");
    free(str);

    str=NULL;
    if (str != NULL)
    {
        strcpy(str, "world");
        printf(str);
    }
}
int main()
{
    Test();
    return 0;
} 

 6.柔性数组

6.1什么是柔性数组

1.在结构体中

2.最后一个成员

3.未知大小的数组

例如：

struct S
{
    int a;
    char n;
    double b;
    int arr[];//未知大小的数组，arr就是柔性数组成员
};

或者

struct S
{
    int a;
    char n;
    double b;
    int arr[0];//未知大小的数组，arr就是柔性数组成员
}; 

6.2柔性数组的特点

1.结构中的柔性数组成员前面必须至少一个其他成员。
2.sizeof 返回的这种结构大小不包括柔性数组的内存。
3.包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

 struct S
{
    int a;
    int arr[];
};
int main()
{
    printf("%zd", sizeof(struct S));//结果为4
    return 0;
}

 struct S
{
    int a;
    int arr[];
};
int main()
{
    struct S*ps=(struct S*)malloc(sizeof(struct S) + 20 * sizeof(int));
    if (ps == NULL)
    {
        perror("malloc");
        return 1;
    }

    free(ps);

    ps=NULL;

    return 0;

}

6.3柔性数组的使用 

struct S
{
    int a;
    int arr[];
};
int main()
{
    struct S*ps=(struct S*)malloc(sizeof(struct S) + 20 * sizeof(int));
    if (ps == NULL)
    {
        perror("malloc()");
        return 1;
    }
    //使用这片空间
    ps->a = 20;
    for (int i = 0; i < 20; i++)
    {
        ps->arr[i] = i + 1;
    }

    free(ps);

    ps=NULL;
    return 0;
}

6.4柔性数组的大小改变 

struct S
{
    int a;
    int arr[];
};
int main()
{
    struct S* ps = (struct S*)malloc(sizeof(struct S) + 20 * sizeof(int));
    if (ps == NULL)
    {
        perror("malloc()");
        return 1;
    }
    //使用这片空间
    ps->a = 20;
    for (int i = 0; i < 20; i++)
    {
        ps->arr[i] = i + 1;
    }
    //改变柔性数组的大小
    struct S* p = (struct S*)realloc(ps, (sizeof(struct S) + 40 * sizeof(int)));
    if (p != NULL)
    {
        ps = p;
        p = NULL;
    }

    else
    {
    perror("malloc");
    return 1;
    }
    for (int i = 0; i < 40; i++)
    {
        printf("%d ", ps->arr[i]);
    }
    free(ps);
    ps = NULL;
    return 0;
}

 或者

struct S
{
    int a;
    int* arr;
};
int main()
{
    struct S* ps = (struct S*)malloc(sizeof(struct S));
    if (ps == NULL)
    {
        perror("malloc");
        return 1;
    }
    int* tmp = (int*)malloc(20 * sizeof(int));
    if (tmp != NULL)
    {
        ps->arr=tmp;

    }
    else
    {
        perror("malloc");
        return 1;
    }
    //给arr中的数赋值为1~20
    for (int i = 0; i < 20; i++)
    {
        ps->arr[i] = i + 1;
    }
    //修改arr的大小
    tmp=(int *)realloc(ps->arr, 40 * sizeof(int));
    if (tmp != NULL)
    {
        ps->arr = tmp;
    }
    else
    {
        perror("malloc");
        return 1;
    }
    for (int i = 0; i < 40; i++)
    {
        printf("%d ", ps->arr[i]);
    }
    //释放,先释放ps里面的arr，再释放ps
    free(ps->arr);
    ps->arr = NULL;
    free(ps);
    ps = NULL;
    return 0;
}

代码1和代码2均能实现同样的功能，但代码1更好一些，因为代码1malloc的次数少，减少的内存碎片，因为malloc开辟的空间是连续的，开辟的多中间空的间隙也多。

7，总结c/c++中程序内存区域划分

竞了么个竞
关注
  • 21
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
C语言中动态内存的开辟
输出分享
04-18 1836
简洁细致的概括和使用动态内存的相关库函数，把内存的使用变得灵活！
C语言的动态内存管理函数
JuLiJuLi.的博客
04-03 1328
C语言的动态内存管理函数.
c语言篇（动态内存管理）
小马同学的博客
12-10 4945
动态内存管理，很重要的一篇文章，看完这篇让你深入理解动态内存的设置，和避免开辟的时候出现的一些问题！！！！
C语言——内存管理
脑壳有点痒，好像要长脑子了！
07-23 1224
C语言中，内存管理需要对静态和动态内存分配，静态分配在编译时确定，而动态分配（如malloc, calloc, realloc）则在运行时进行，需程手动管理，包括适时释放（用free）以避免内存泄漏。同时，了解栈、堆、数据区、代码区等内存区域的特性和用途，对于有效管理内存至关重要。
C语言：动态内存管理
热门推荐
weixin_51142926的博客
01-17 1万+
学习数据结构之前，一定要对指针、结构体、动态内存管理进行深入学习！
c语言中的动态内存
m0_71158751的博客
08-06 959
我们的程序对象存储的位置有静态内存和动态内存还有栈内存，静态内存里存储着局部static对象，类的static数据成员以及定义在任何类外的变量，栈内存里保存着定义在函数内的非static对象，分配在静态内存或栈内存中的对象有着严格的生存期，由编译器自动生成和销毁。但有时我们需要在程序运行时动态分配对象，这个时候就需要用到动态内存了，动态内存的生存期由程序来控制，也就是说，我们必须在使用完程序后释放这部分内存，否则就会造成内存泄漏。......
C语言之动态内存管理
一只小卷毛的博客
11-07 925
动态内存管理（含四个关于动态内存开辟的函数以及柔性数组）
c语言-实现动态内存管理的库函数
pyc68的博客
01-21 1512
本篇文章介绍c语言中实现动态内存管理的库函数，比如malloc()、free()、calloc()、realloc()
【C语言】C语言中的动态内存
Hush_H的博客
10-09 794
详解C语言中的动态内存分配
模拟实现C语言中的内存管理
09-03
在C语言中，内存管理是程序员直接负责的重要任务。它涉及到动态分配、释放内存以及确保内存的有效使用。本文将通过模拟实现C语言中的内存管理机制，来深入理解这些概念。 首先，C语言提供了三个主要的内存区域：栈...
C语言的内存管理机制
02-24
本文是作者在学习C语言内存管理的过程中做的一个总结。全局变量（外部变量）：出现在代码块{}之外的变量就是全局变量。局部变量（自动变量）：一般情况下，代码块{}内部定义的变量就是自动变量，也可使用auto显示...
C语言动态内存管理笔记
03-09
个人学习总结
C语言实现内存管理
03-21
在编程世界中，C语言因其低级特性而被广泛用于系统级编程，其中包括内存管理。内存管理是程序设计中的核心部分，它涉及到如何有效地分配、使用和释放内存资源。本主题将深入探讨如何使用C语言来实现内存管理的关键...
【ARM】解析MDK生成的C Compiler list文件的具体内容
Emdoorelec的博客
08-12 364
用于解析MDK生成的C Compiler list文件的具体内容。
【C语言】输入/输出函数详解
最新发布
EleganceJiaBao的博客
08-14 607
以上是C语言中常用的输入/输出函数的详细说明，包括它们的函数原型、参数说明、返回值说明以及示例代码。这些函数是进行输入/输出操作的基础，掌握它们是编写C程序的关键。通过这些示例代码，你可以更好地理解每个函数的使用方法，并在实际编程中灵活运用。
python学习之zip（）和map（）
li758568825的专栏
08-12 860
它用于将一个给定的函数应用于可迭代对象（如列表、元组、字符串等）的每个元素，返回一个由这些函数调用结果组成的迭代器。print(list(unzipped)) # 输出: [(1, 2, 3), ('a', 'b', 'c')]返回一个迭代器`Map`，它生成从可迭代对象中提取的元素经过 `function` 处理后的结果。print(list(zipped)) # 输出: [(1, 4), (2, 5)]`zip()` 可以把多个序列中的元素配对。# 较短的可迭代对象耗尽后，不再产生新的元组。
C++笔记-sstream的使用（字符串转其他类型，读取文件时用得多）
IT1995的博客
08-12 306
在 C++ 中，std::stringstream 类可以用来进行字符串流的输入输出，将字符串和其他类型的数据进行转换。
C++基础知识：友元是什么，友元（全局函数做友元）
我就知道你会来，我们一起进步吧！
08-12 225
在程序里，有些私有属性 也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术。通俗一点说就是友元，就好比你的闺蜜，你可以让他了解你身上的特有的东西。友元的目的就是让一个函数或者类 访问另一个类中私有成员。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值