潜学C语言——动态内存分配

最新推荐文章于 2024-03-25 15:11:20 发布

流继承

最新推荐文章于 2024-03-25 15:11:20 发布

阅读量539

点赞数 5

分类专栏：比特牛的C语言之路文章标签： c语言开发语言

本文链接：https://blog.csdn.net/m0_66307842/article/details/123327740

版权

比特牛的C语言之路专栏收录该内容

15 篇文章 0 订阅

订阅专栏

首先介绍一下C/C++程序内存分配的几个区域：

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

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

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

4.代码段:存放函数体(类成员函数和全局函数)的二进制代码。

关于static关键字修饰局部变量的例子：

实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。

但是被static修饰的变量存放在数据段(静态区)，数据段的特点是在上面创建的变量，直到程序结束才销毁所以生命周期变长。(下面会讲到例子)

当前我们知道的内存的使用方式：

1.创建一个变量

int a =10; //局部变量 - 栈区在栈空间上开辟四个字节

int g_a = 10; //全局变量 - 静态区

char arr [10] = { 0 };//在栈空间上开辟10个字节得到连续空间

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

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

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

动态内存函数的介绍

malloc 和 free（它们的声明在 stdlib.h 头文件中）

C语言提供了一个动态内存开辟的函数

void* malloc(size_t size);

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

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

如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要检查

返回值的类型是void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。

如果参数size为0 , malloc的行为是标准是未定义的,取决于编译器。

C语言提供了另外一个函数free ,专门是用来做动态内存的释放和回收的，函数原型如下:

#include<stdlib.h>
int main()
{
	//向内存申请10个整型空间
	int* p = (int*)malloc(10 * sizeof(int));

	return 0;
}

free函数：

用来做动态内存的释放与回收

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

如果参数 ptr 是NULL指针，则函数什么事也不做

#include<stdlib.h>
int main()
{
	//向内存申请10个整型空间
	int* p = (int*)malloc(10 * sizeof(int));
	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;//
	return 0;
}

注意：malloc函数和free要成对使用

calloc

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

与函数malloc的区别只是在于calloc会在返回地址之前把申请的空间的每个字节初始化为全0

如下图

void* calloc(size_t num, size_t size);

int main()
{
	//malloc(10*sizeof(int));
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
	}
	else
	{
		int o = 0;
		for (i = 0; i < 10; i++)
		{
			printf("%d", *(p + i));
		}
	}
	//释放空间
	//free函数是用来释放动态内存开辟的空间的
	free(p);
	p = NULL;
	return 0;
}

当我们对申请的内存空间的内容要求初始化，那么可以使用calloc函数

realloc

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

ptr 是要调整的内存地址

size 调整之后的新大小

返回值为调整之后的内存起始地址

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

realloc在调整内存空间的是存在两种情况

情况1：原有空间之后有足够大的空间（扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化）

情况2：原有空间之后没有足够的空间——开辟新空间（在堆空间上寻找另一个合适大小的连续空间来使用），这时函数返回一个新的内存地址

realloc函数的使用：

int main()
{
	int* p = (int*)malloc(20);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
	}
	else
	{
		int i = 0;
		for (i = 0; i < 5; i++)
		{
			*(p + i) = i;
		}
	}
	//就是在使用malloc开辟的20个字节空间
	//假设这里20个字节已经不满足我们使用了
	//希望可以有40个字节的空间
	//这里可以使用realloc来调整动态开辟的内存
	int* p2 = realloc(p, 40);
	int i = 0;
	for (i = 5; i < 10; i++)
	{
		*(p2 + i) = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d", *(p2 + i));
	}

	return 0;
}

realloc使用的注意事项：

1.如果p指向空间之后有足够的内存空间可以追加，则直接追加，后返回p

2.如果p指向空间之后没有足够的内存空间可以追加，则realloc函数会重新找一个新的内存区域，开辟一块满足需求的空间，并且把原来内存中的数据拷贝回来，释放旧的内存空间，最后返回先新开辟的内存地址

3.要用一个新的变量来接受realloc函数的的返回值

如

int* ptr = realloc(p, 40);
	if (ptr != NULL)
	{
		p = ptr;
	}

常见的动态内存的错误

1.对NULL指针的解引用操作

//错误示范
int main()
{
	int* p = (int*)malloc(40);
	//万一malloc失败，p就被赋值为NULL
    //*p = 0;//err
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;

	return 0;
}

要对p进行相关的判断

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

int main()
{
	int* p = (int*)malloc(5 * sizeof(int));
	if (p == NULL)
	{
		return 0;
	}
	else
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p = i) = i;
		}
	}
	free(p);
	p = NULL;

	return 0;
}

3.对非动态开辟内存的free

int main()
{
	int a = 10;
	int* p = &a;
	*p = 20;
	free(p);
	p = NULL;
	return 0;
}

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

int main()
{
	int*p(int)malloc(40);
	if (p == NULL)
	{
		return 0;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p++ = i;
	}
	//回收空间
	free(p);
	p = NULL;
	return 0;
}

5.对同一块动态内存的多次释放ruhe

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 0;
	}
	//使用
	//释放
	free(p)
	//......
	free(p);

	return 0;
}

如何避免：在free（p）后加上 p = NULL;

6.对动态开辟内存的空间忘记释放（内存泄漏）

while (1)
{
	malloc(1);
}
return0;

几道经典题目：

1.这个程序出现了什么错误


void GetMemory(char* p)
{
	p = (char*)malloc(100);
}

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

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

程序崩溃

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 world");
	prinf(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");
	prinf(str);
	free(str);
	str = NULL;
}

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

2.下列代码会出现什么问题

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创建的空间在离开函数GetMemory的时候已经将这块空间还给操作系统

相似的例子：

int* test()
{
	int a = 10;//栈区
	return &a;
}
int main()
{
	int *p = test();
    *p = 20;
	return 0;
}

同为返回栈空间的地址的问题

改正：

加长a的生命周期，把a放在静态区——static

int* test()
{
	static int a = 10;//栈区
	return &a;
}
int main()
{
	test();
	return 0;
}

举例：

int* test()
{
	int* ptr = malloc(100);//堆区
	return ptr;
}
int main()
{
	int* p = test();
	return 0;
}

堆空间的空间只有free可以回收

3.请问运行Test函数会有什么样的结果？

int* test()
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	if(str!=NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}

Answer：会篡改动态内存区的内容。因为free（str）之后，str成为野指针，if（str！=NULL）语句不起作用

改正：

int* test()
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	str = NULL;
	if(str!=NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}

柔性数组：

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

柔性数组的特点:

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

typedef struct st_type
{
    int i;
    int a[];//柔性数组成员
}

2.sizeof返回的这种结构大小不包括柔性数组的内存。

struct S
{
	int n;
	int arr[];//柔性数组成员
};

int main()
{
	printf("%d\n", sizeof(struct S));
	return 0;
}

3.包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

使用：

struct S
{
	int n;
	int arr[0];//未知大小的-柔性数组成员-数组的大小是可以调整的
};
int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 5 * sizeof(int));
	return 0;
}

如果不使用柔性数组

struct S
{
	int n;
	int* arr;
};
int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	ps->arr = malloc(5 * sizeof(int));

	int i = 0;
	for (i = 0; i < 5; i++)
	{
		ps->arr[i] = i;
	}
	for (i = 0; i < 5; i++)
	{
		printf("%d", ps->arr[i]);
	}
	//调整大小
	int *ptr = relloc(ps->arr, 10 * sizeof(int));
	if (ptr != NULL)
	{
		ps->arr = ptr;
	}
	for (i = 5; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d", ps->arr[i]);
	}
	//释放内存
	free(ps->arr);
	ps->arr = NULL;
	free(ps);//释放两次
	return 0;
}

使用柔性数组有两个好处：

1.方便内存的释放

2.利于访问速度：连续的内存有益于提高访问速度