动态内存管理

目录

一、动态内存分配

二、动态内存函数

1.malloc 和 free

2.calloc

3.realloc

三、常见的动态内存错误

1.对NULL指针的解引操作

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

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

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

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

6.动态开辟内存忘记释放(内存泄漏)

四、经典笔试题

五、C/C++程序的内存开辟 

六、柔性数组

1.柔性数组的特点

2.柔性数组的使用

3.柔性数组的优势


动态内存管理_第1张图片

一、动态内存分配

对于内存分配,我们之前已经学过在栈空间开辟的局部变量

int main() 
{
	int var = 20;//局部变量在栈空间开辟四个字节
	char arr[10] = {0};//在栈空间开辟10个字节的连续空间
	return 0;
}

上述开辟空间的方式有两个特点:

  1. 空间开辟的大小是固定的
  2. 数组在声明的时候,必须指定数组的长度,它所需要的内存在编译时分配

但是如果只是这样,有时候我们需要的空间大小在程序运行的时候才能知道,那数组的编译时开辟空间的方式就不能满足了。这时就可以采取动态内存开辟

二、动态内存函数

1.malloc 和 free

malloc函数

void* malloc (size_t size);

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

  • 如果开辟成功,则返回一个指向开辟好空间的指针
  • 如果开辟失败,则返回一个NULL指针,因此malloc的返回值一定要做检查
  • 返回值的类型是 void* ,所以malloc函数并不知道开辟空间的类型,具体在使用的时候使用者自己来决定
  • 如果参数 size 为0,malloc的行为是标准是未定义的,取决于编译器
#include
#include
int main() 
{
	//申请一块空间,来存放5个整型
	int* p = (int*)malloc(sizeof(int)*5);//因为mallc原返回类型是void*,这里要进行强制类型转化
	if (p == NULL)
	{
		perror("malloc");//如果开辟失败会返回关于malloc的信息
		return 1;
	}
	return 0;
}

 malloc 申请的空间是在内存堆区上申请的空间,而不是栈区上

 动态内存管理_第2张图片

如何使用malloc 

#include
#include
int main() 
{
	//申请一块空间,来存放5个整型
	int* p = (int*)malloc(sizeof(int)*5);//因为mallc原返回类型是void*,这里要进行强制类型转化
	if (p == NULL)
	{
		perror("malloc");//如果开辟失败会返回关于malloc的信息
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 5;i++) 
	{
		*(p+i) = i;
	}
	//打印
	for (i = 0; i < 5; i++)
	{
		printf("%d ", * (p + i));
	}
	free(p);
	p = NULL;
	return 0;
}

 动态内存管理_第3张图片

对于上述malloc开辟的空间,上述使用完后,是使用free进行释放的

关于malloc函数的释放

1.  free 释放,这是一种主动释放   2. 程序退出后,malloc申请的空间也会被操作系统回收的(被动)

我们在写代码的正常情况下,谁申请的空间,谁去释放; 万一自己没有释放,也要交代给别人,记得释放,避免内存泄漏。

 free函数

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

void free (void* ptr);

 free函数用来释放动态开辟的内存

  • 如果参数 ptr 指向的空间不是动态开辟的,那free函数的行为是未定义的
  • 如果参数 ptr 是NULL指针,则函数什么事都不做

注意: 使用 malloc 和 free 要引用头文件  stdlib.h

动态内存管理_第4张图片

2.calloc

calloc也是用来开辟内存空间的

void* calloc (size_t num, size_t size);

动态内存管理_第5张图片

我们发现calloc 与malloc 很像

就比如 申请10个整型的空间

calloc(10,sizeof(int));

而上方的malloc

malloc(10*sizeof(int));

除了参数的区别,还有

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

calloc 函数的使用

//calloc内存函数的使用
#include
#include
int main() 
{
	//动态分配5个整型空间
	int* p = (int *)calloc(5,sizeof(int));//动态分配并初始化空间,元素置零
	if (p == NULL)
	{
		perror("calloc");//如果动态分配失败,打印关于calloc的错误信息
	}
	int i = 0;
	//打印元素的值
	for (i = 0; i < 5;i++) 
	{
		printf("%d",*(p+i));
	}
	printf("\n");
	//元素赋值
	for (i = 0; i < 5;i++) 
	{
		*(p + i) = i;
		//二次打印
		printf("%d",*(p+i));
	}
	//使用free 函数进行空间释放,避免内存泄露
	free(p);
	p = NULL;//记得置为空
	return 0;
}

所以当我们需要 动态分配内存空间并且需要初始化,使用calloc是一种很好的选择

3.realloc

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

对于动态内存函数realloc函数更加灵活

有时我们使用malloc和calloc函数进行动态内存分配的时候,我们发现所分配的空间已经固定下来,那木我们就会想 会不会有一种可以调整动态内存大小的动态分配的内存函数呢?接下里就就是我们介绍的realloc内存函数,可以对动态内存空间进行重新调整大小。

  •  ptr 是要调整的内存地址
  • size 调整之后新大小
  • 返回值为调整之后的内存起始位置
  • 这个函数调整原内存空间大小的基础上,还会将原来内存中的数据移动到 的空间
  • realloc在调整内存空间的是存在两种情况 
    情况1
    动态内存管理_第6张图片
    情况2
    动态内存管理_第7张图片

realloc函数的使用

//使用calloc 开辟空间,使用realloc调整空间
#include
#include
int main() 
{
	//比如开辟5个整型空间
	int* p = (int*)calloc(5,sizeof(int));
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5;i++)
	{
		*(p + i) = i;
	}
	//这里希望调整为10个整型的空间
	int* ptr = (int*)realloc(p,10*sizeof(int));
	if (ptr != NULL)
	{
		p = ptr;//如果开辟成功,p指向ptr
	}
	//给后续的5个空间赋值
	for (i = 5; i < 10; i++)
	{
		*(p + i) = i;
	}
	//打印
	for (i = 0; i < 10; i++)
	{
		printf("%d ",* (p + i));
	}
	free(p);
	p = NULL;
	return 0;
}

 注意  如果realloc的第一个参数为NULL 就等价于 malloc 

realloc(NULL,10*sizeof(int))   ==    malloc(10*sizeof(int))

三、常见的动态内存错误

1.对NULL指针的解引操作

//对NULL指针的解引操作
int main()
{
	int* p = (int*)malloc(40);
	//没有对返回值判断,可能开辟内存失败,就使用了NULL指针,解引用
	*p = 20;
	free(p);
	return 0;
}

这里的改正应该是加上对空指针的判断语句

int main()
{
	int* p = (int*)malloc(40);
	if (p== NULL)
	{
		;
		//.....
	}
	*p = 20;
	free(p);
	return 0;
}

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

#include
#include
int main()
{
	int* p = (int*)malloc(5 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i <= 5;i++)//注意这里的等于号,越界访问了
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
	return 0;
}

动态内存管理_第8张图片

即使是动态内存函数开辟的空间,也是不能越界访问的

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

void test()
{
    int a = 10;
    int *p = &a;
    free(p);//这样是错误的
}

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

//使用free释放一块动态开辟内存的 一部分
void test() 
{
	int* p = (int*)malloc(100);
	p++;
	free(p);//注意这里是释放部分动态开辟的内存
}

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

void test() 
{
	int* p = (int*)malloc(100);
	free(p);

    //...

	free(p);//重复释放是不对的
}

6.动态开辟内存忘记释放(内存泄漏)

void test() 
{
	int* p = (int*)malloc(100);
	if (p != NULL) 
	{
		*p = 20;
	}
}
int main() 
{
	test();
	//..
	return 0;
}

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

动态开辟的空间一定要释放,并且正确释放

四、经典笔试题

分析下方代码

题1

//题1
#include
#include
#include
void GetMemory(char* p)
{
	p = (char*)malloc(100);
}
void Test(void) 
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str,"hello word");
	printf(str);
}
int main() 
{
	Test();
	return 0;
}

解析 

动态内存管理_第9张图片

 代码改正

#include
#include
#include
void GetMemory(char** p)
{
	*p = (char*)malloc(100);//*p找到外面的str
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str);//要想获取修改后的str,这里要把str的地址传过去
	strcpy(str, "hello word");//这时str指向存放100个字节的空间,然后把字符串拷贝过去
	printf(str);//打印
	//释放空间
	free(NULL);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

修改方法二

#include
#include
#include
char* GetMemory()
{
	char *p = (char*)malloc(100);
	return p;//返回p
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	strcpy(str, "hello word");//这时str指向存放100个字节的空间,然后把字符串拷贝过去
	printf(str);//打印
	//释放空间
	free(NULL);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

题2

//题二
#include
#include
char* GetMemory() 
{
	char p[] = "hello world";
	return p;
}
void Test() 
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
int main() 
{
	Test();
	return 0;
}

解析 

动态内存管理_第10张图片

 题3

//题3
#include
#include
#include
void GetMemory(char**p, int num) 
{
	*p = (char*)malloc(num);
}
int main() 
{
	char* str = NULL;
	GetMemory(&str,100);
	strcpy(str,"hell0");
	printf(str);
	return 0;
}

解析

少了free(存在内存泄漏问题)

题4

//题4
void Test() 
{
	char* str = (char*)malloc(100);
	strcpy(str,"hello");
	free(str);
	if (str != NULL) 
	{
		strcpy(str,"word");
		printf(str);
	}
}
int main() 
{
	Test();
	return 0;
}

解析 

动态内存管理_第11张图片

五、C/C++程序的内存开辟 

在C/C++中,内存的开辟可以使用以下方法:

1. 静态内存分配:在编译时就分配好内存空间,例如定义全局变量和静态变量时所使用的内存就是静态内存。静态内存的特点是不需要程序员手动释放,但是分配的内存大小在编译时就已经确定,有一定的局限性。

2. 栈内存分配:在函数内部定义的局部变量所使用的内存就是栈内存,函数执行时自动分配内存,函数退出时自动释放内存。栈内存的特点是速度快,但分配的内存大小有限,可能会导致栈溢出。

3. 堆内存分配:使用动态内存分配函数(如malloc、new等)在堆中分配内存,程序员手动申请和释放内存。堆内存的特点是使用灵活,但需要程序员手动释放内存,否则会导致内存泄漏。

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

所以生命周期变长

六、柔性数组

柔性数组(Flexible Array)是一种特殊的数组类型,在定义数组时可以不指定其长度,而是通过程序运行时动态地分配数组空间

struct flex_array {
    size_t len;
    int data[]; // 柔性数组,未知大小的数组
};
 

其中,data就是柔性数组,它的长度可以在程序运行时动态调整,而len则记录了数组当前的长度。在使用柔性数组时,通常需要使用动态内存分配函数(如malloccalloc等)来为其分配空间,同时也需要注意在使用完毕后及时释放内存,以避免内存泄漏等问题

1.柔性数组的特点

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

2.柔性数组的使用

#include
#include
struct S 
{
	char c;
	int i;
	int arr[];
};
int main() 
{
	struct S* ps = (struct S*)malloc(sizeof(struct S)+20);
	if (ps == NULL) 
	{
		perror("malloc");
		return 1;
	}
	ps->c = 'w';
	ps->i = 100;
	int i = 0;
	for (i = 0; i < 5;i++) 
	{
		ps->arr[i] = i;
	}
	//打印
	for (i = 0; i < 5;i++)
	{
		printf("%d ",ps->arr[i]);
	}
	printf("%c %d",ps->c,ps->i);
	//当空间不够用就使用realloc 继续增加
	struct S* ptr = (struct S*)realloc(ps,sizeof(struct S*)+40);
	if (ptr == NULL)
	{
		perror("realloc");
		return 1;
	}
	free(ps);
	ps = NULL;
	return 0;
}

3.柔性数组的优势

方便内存释放:

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

有利于提高访问速度:

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

你可能感兴趣的:(【C语言】,C语言)