【一起来学C】动态内存分配

于 2021-09-26 18:38:56 发布
阅读量204 收藏 5
点赞数 8
分类专栏： C语言 文章标签： c语言 c++ 动态内存分配
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51574797/article/details/120461712
版权

动态内存分配

前言：

如果可以随意的开辟内存，随用随开，这样是不是就可以使内存的使用更加高效化呢？就不会出现开辟多了用不完，开辟少了不会用的情况了。动态内存开辟就解决了这一问题。

开辟的位置

内存中大致可以分为3个位置：

  1. 栈区：存放局部变量和函数形参
  2. 静态区：存放静态变量和全局变量
  3. 堆区：动态开辟的变量

我们今天研究的动态内存就存放再堆区中

malloc介绍

函数原型

头文件stdlib.h或malloc.h

void* malloc(sizze_t num);

num代表字节数，malloc将num个字节数全部都开辟出来供我们使用。

具体使用：

#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		printf("malloc fail\n");
	}
	else
	{
		for (int i = 0; i < 10; i++)
		{
			*(p + i) = 0;
		}
	}
    free(p);
	return 0;
}

注意事项：

  1. 记住要使用指针来接受。因为malloc返回的是内存中的地址，所以要记录下内存的地址，所以要使用指针来接受
  2. ==要强制转换成其他类型。==正因为malloc的函数是void*类型，所以它的目的就是为了可以被强制转化成其他类型的数字，方便使用。
  3. malloc完毕一定要记住判段开辟来的指针是否为空，因为开辟不一定成功。开辟不成功就会返回NULL
  4. malloc使用完毕一定要free掉。不然，它会一直占用内存中的空间，影响了内存

这四条都特别重要，都是特别容易忽略的

free介绍

当malloc内存之后，我们一定不要忘记free掉它们，下面我们就具体来看一看free的性质

重点：

在我们free掉开辟的内存的时候，我们的程序会将开辟的内存释放，将内存还给操作系统，内容会变成随机值。但是，那个接受的指针却还记录着那个地方的地址，这样就可能会有内存泄漏的风险。所以我们要将free掉的值置成NULL

未free前：
在这里插入图片描述

free后：
在这里插入图片描述
可以看出free后，虽然还给了操作系统，但是还p的值还记录着呢。所以一定要把p置为NULL

calloc介绍

calloc和malloc非常的相似，只是calloc多了一个初始化为0

函数原型：

void* calloc(size_t num,size_t size);

注意：

  1. num是所要开辟的内存的大小
  2. size是所开辟内存的所占的字节数
  3. calloc会自动的为新开辟的内存初始化成0

具体实现

#include<string.h>
#include<errno.h>
int main()
{
	int* p = (int*)calloc(100000000000000, sizeof(int));
	if (p == NULL)
	{
		printf("%s", strerror(errno));
		//perror("");
	}
	else
	{
		for (int i = 0; i < 10; i++)
			printf("%d", *(p + i));
	}
	return 0;
}

在这里插入图片描述

realloc介绍

函数原型：

void* realloc(void* ptr,size_t size)

  • ptr是想要调整内存的地址。

  • size是调整后新内存的总大小

  • realloc在调整内存的时候存在着两种情况

    情况1

    realloc后面的内存容量足够的大，足够开辟size个字节个内存。

在这里插入图片描述
此时，ptr指向不变，只是内存扩大到2倍。

​ 情况2

​ realloc后面的内存容量不够开辟size个字节的内存。需要在内存系统中重新寻找有着size个连续内存的单元。

在这里插入图片描述

具体实现

int main()
{
	int* p = (int*)malloc(10);
	if (p == NULL)
		printf("%s", strerror(errno));
	else
	{
		int* ptr = (int*)realloc(p, 20);//新开辟一个指针进行保存
		if (ptr == NULL)//如果realloc失败就返回NULL
		{
			printf("%s", strerror(errno));
		}
		else//如果成功了就把新开辟的空间的指针赋予新的指针
		{
			p = ptr;
		}
	}
	free(p);
}

常见的开辟内存的错误

void test()
{
int i = 0;
int *p = (int *)malloc(10*sizeof(int));
if(NULL == p)
{
	exit(EXIT_FAILURE);
}
for(i=0; i<=10; i++)
{
	*(p+i) = i;//当i是10的时候越界访问
}
	free(p);
}

很容易出现的问题就是使用未属于我们开辟的内存，这样就造成了越界访问。这是千万要注意的。

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

对于非动态开辟的内存，不属于堆中的内存，所以不可以使用free去释放

void test()
{
	int a = 10;
	int *p = &a;
	free(p);//ok?
}

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

void test()
{
	int *p = (int *)malloc(100);
	p++;
	free(p);//p不再指向动态内存的起始位置
}

这样也是不对的，因为要free掉的内容必须是我们开辟的内存的首指针。

不能只free掉开辟内存的一部分。

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

void test()
{
	int *p = (int *)malloc(100);
	free(p);
	free(p);//重复释放
}

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

void test()
{
	int *p = (int *)malloc(100);
	if(NULL != p)
	{
		*p = 20;
	}
}
int main()
{
	test();
	while(1);
}

这就是忘记开辟的内存的内存释放了，这就会造成内存泄漏，十分危险，所以一定要注意要free掉。

经典面试题

经典的值传递和址传递的问题

判断下面的做法正确吗：

void GetMemory(char* p)
{
	p = (char*)malloc(100);
}
//p是形参，改变了形参的内容，无法改变实参的内容。所以str的值还是NULL
void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	//对strcpy来说，两个指针都不能是NULL的，也就是不能没有指向的指针。
	//所以走到这里的时候，程序崩溃。
	printf(str);
}
int main()
{
	Test();
}

正确的做法：地址传递,就解决了上面str是NULL的问题

void GetMemory(char** p)
{
	*p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str);
	strcpy(str, "hello world");
	printf(str);
    free(str)//千万不要忘记释放
}
int main()
{
	Test();
	return 0;
}

直接返回地址

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);//千万不要忘记释放
}
int main()
{
	Test();
	return 0;
}

接上面的返回地址

对于上面的问题，难道所有的都可以返回地址来补救错误吗，不是的。

对于下面这种：

//********************************接上一条改动***********************************
char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
//和上一条改动一样，返回地址可不可以呢？
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
int main()
{
	Test();
	return 0;
}

答案是不可以，因为跟上一条改动不同的是，上一条是堆上开辟的内存，出了函数并不会销毁。
但是，这个是栈上开辟的内存，出了函数这个p就记录的不是hello world的地址了，只是一个普通的值
所以会返回“烫烫烫烫烫烫烫烫,”2333333333333

所以，这告诉了我们一个重要的结论：

只有堆上开辟的内存可以返回，栈上开辟的内存是不可以返回的。

int* test()
{
	int n = 10;
	return &n;
}
int main()
{
	int* i = test();
	printf("hehe\n");
	printf("%d", *i);
}

虽然上面的程序很简单，但是它也是返回了栈上的地址，虽然没有printf("hehe\n");很有可能会输出n的值(没有被覆盖），但是有了

printf("hehe\n");后，n的值被覆盖后就返回一个随机值5了。

所以，一定要记住，我们是不可以返回栈上开辟变量的地址的，堆上的还可以理解，但是栈上的是真的不行。

别忘记free掉开辟的首地址

下面这个有什么问题呢？怎么改正？

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;
}

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;
}

注意：

这个实现没有任何的问题，只有一点是容易忽略的，那就是没有free掉动态申请的内存
另外，free不一定非要在申请的函数内部free，只要记住了malloc的首地址就可以在任意地方进行free

不要忘记置为NULL

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;
}

这个是什么问题呢？

是free之后忘记置NULL，还继续使用野指针。

C/C++在内存的位置开辟

在这里插入图片描述
**C/C++程序内存分配的几个区域： **

  1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些
    存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有
    限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。、
  2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似
    于链表。
  3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
  4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码，还存放只读常量：常量字符串

特别需要注意的一点是：

静态变量：

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

柔性数组

柔性数组是在结构体中的一种数组。这种数组可以不指定数组的长度

要求：

  1. 在结构体中柔性数组的前面必须要有变量
  2. 在结构体中柔性数组不占用结构体的内存
  3. 用动态内存开辟空间的时候要带有着柔性数组+其他变量，不可以只开辟柔性数组的大小，要开辟整个数组的大小

柔性数组的使用

struct type
{
	int i;
	int a[];//柔性数组必须前面要有变量
};
int main()
{
	struct type* p = (struct type*)malloc(sizeof(struct type) + 10 * sizeof(int));
	//注意：必须要开辟整个结构体的空间
	//如果开辟失败
	if (p == NULL)
	{
		printf("%s", strerror(errno));
		return -1;
	}
	//开辟成功了
	p->i = 2;
	for (int j = 0; j < 10; j++)
	{
		p->a[j] = j;
	}
	for (int j = 0; j < 10; j++)
	{
		printf("%d ", p->a[j]);
	}
	//内存不够用,开辟成20个大小的数组
	struct type* ptr = (struct type*)realloc(p, sizeof(struct type) + 20 * sizeof(int));
	if (ptr == NULL)
	{
		printf("%s", strerror(errno));
		return -1;
	}
	p = ptr;
	//使用
	//释放——千万要记住释放

	free(p);
	p = NULL;
	return 0;

}

柔性数组的优势

同样的功能我们还可以采用下面这种方式：

typedef struct st_type
{
	int i;
	int *p_a;
}type_a;
type_a *p = malloc(sizeof(type_a));
p->i = 100;
p->p_a = (int *)malloc(p->i*sizeof(int));
//业务处理
for(i=0; i<100; i++)
{
	p->p_a[i] = i;
}
//释放空间
free(p->p_a);
p->p_a = NULL;
free(p);
p = NULL;

从这种方式我们可以看到，我们不但要开辟结构体，还要开辟结构体的数组。这样就要进行多次的free，而这样就会造成可能会多的内存泄漏的风险。

优点1：

如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用
户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发
现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体
指针，用户做一次free就可以把所有的内存也给释放掉。

优点2：

连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了
要用做偏移量的加法来寻址）

CAFE～BABE
关注
  • 8
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值