关于动态内存管理的一些理解

Posted 2021-09-06 正义的伙伴啊

动态内存管理

文章目录

• 动态内存管理
• • 为什么要存在动态内存分配
  • 动态内存函数的介绍
  • • malloc
    • free
    • calloc
    • realloc
    • • 注意事项：
  • 动态内存常见的错误
  • • 对申请的动态空间不进行NULL检查
    • 对动态开辟的空间越界访问
    • 对非动态内存使用free释放
    • 使用free释放一块动态开辟内存的一部分
    • 对同一块内存多次释放
    • 动态开辟内存忘记释放（内存泄露）
  • 几个经典的笔试题
  • • 1
    • 2
    • 3
  • c/c++内存开辟
  • 柔性数组
  • • 柔性数组的定义
    • 柔性数组的特点

为什么要存在动态内存分配

我们现在知道的开辟的空间的方式只有直接声明变量，例如：

    int a = 3;
	char b[5] = { 1,2,3 };

我在学习数组的时候告诉我们定义数组时，例如：int a[n]。n必须时常量，而不能是变量。当时我就在想这样的规定是多么的不人性化，因为n是常量的时候，你必须在定时数组的时候就预先知道数组的大小，特别是在处理一些复杂的问题的时候数组的大小是变化的，当时我就在想为什么不能在代码运行过程中调整数组的大小？直到我学到了动态内存管理一切疑惑才解开。

上述就是开辟的空间的两个特点：

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

在这里多补充一下计算机内存的结构：

我们平时申请的变量其实都是在栈区上申请的，下面介绍的动态内存开辟函数都是在堆区上开辟的

动态内存函数的介绍

malloc

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

void* malloc(size_t size);

这个函数向内存申请一块连续可用的空间，并返回指向这块空间首地址的指针：

1. 如果开辟成功，则返回一个指向开辟好空间的指针
2. 如果开辟失败，则返回一个NULL指针，因此malloc返回值一定要做检查。
3. 返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
4. 如果参数size为0，malloc的行为是未定义的，取决于编译器。

free

c语言专门提供了一个回收和释放动态内存的函数

void free(void* ptr);

• 如果参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的（只能释放动态开辟的空间）
• 如果参数ptr是NULL指针，则函数什么事都不做
• 使用完free函数后，内存被释放但是指针依然指向那片内存，所以要手动将指针置为空指针，防止指针非法访问。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int num = 0;
	scanf("%d", &num);
	int* ptr = (int*)malloc(num * sizeof(int));
	if (ptr == NULL)  //判断动态内存是否开辟成功
		printf("开辟失败");
	else
	{
		for (int i = 0; i < num; i++)
		{
			ptr[i] = i;
		}
	}
	free(ptr);//释放开辟的动态空间
	ptr = NULL;
}

这里就模拟实现了数组的动态开辟。

calloc

c语言还提供了一个功能与malloc功能相似的函数calloc

void* calloc(size_t num, size_t size);
//参数含义是开辟num个大小为size的空间

• 函数的功能是为num个大小为size的元素开辟一块空间，并且白空间的每个字节初始化为0
• 与函数malloc的区别只在于calloc会在返回地址之前把申请的空间的每个字节初始化为全0

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		printf("开辟内存失败");
	}
	else
	{
		//使用空间
	}
	free(p);
	p = NULL;
	return 0;

}

我们开始调试并打开内存监视，输入p的地址，便可以看到内存将动态开辟的内存全部初始化为0了

realloc

realloc函数让内存开辟更加方便和灵活。我有时候开辟的空间太小，有时候开辟的过大，realloc
可以对动态内存进行灵活的调整，函数原型如下：

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

• ptr是要调整的内存地址
• size是调整之后的新大小
• 返回值为调整之后的内存起始位置（是整个动态内存的起始位置，而不是增加的内存起始位置）
• 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间（注意新空间包括原来的空间和调整参数空间的大小，返回的地址是新空间的首地址）
  
• realloc在开辟空间时存在两种情况：
  1. 原有空间后有足够大的空间

这种情况就是直接在原有内存之后直接追加空间，原来空间的数据不发生改变。
2. 原有空间后没有足够大的空间

解决方法时在堆空间上另找一个合适大小的连续空间来使用，函数返回一个新的内存地址。旧地址会被free掉

注意事项：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* ptr = (int *)realloc(NULL, 100);
	if (ptr == NULL)
		printf("开辟失败");
	else
	{
		//扩容方法一
		ptr = (int *)realloc(ptr, 100);
		//扩容方法二
		int* p = NULL;
		p = (int*)realloc(ptr, 100);
		if (p != NULL)
			ptr = p;
		free(ptr);
		ptr = NULL;
	}
}

两种扩容方法，方法一存在一个错误就是当扩容失败的时候realloc会返回空指针，空指针赋给ptr会导致ptr储存的地址丢失，而方法二更加保险，创建了一个指针来接受库容后的地址，然后进行判断最后赋值。

动态内存常见的错误

对申请的动态空间不进行NULL检查

void main()
{
	int* p = (int*)malloc(100);
	*p = 4;
	free(p);
	p = NULL;
}

malloc开辟的动态空间一定要检查是不是为NULL指针！！！！！！！！！！！！！上面的代码是妥妥的错误代码。

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

void main()
{
	int* p = (int*)malloc(10*sizeof(int));
	if (p != NULL)
	{
		for (int i = 0; i < 11; i++)
		{
			p[i] = i;
		}
	}
	free(p);
	p = NULL;
}

这里动态开辟了10个int类型的空间，但是赋值的时候要赋11个值，导致了非法访问。这点和数组的越界访问一样，开辟多大的空间访问多大的内存；

对非动态内存使用free释放

不能使用free释放非动态内存

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

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

这里p的地址被改变不在指向动态内存的首地址，导致free在释放内存时出现问题

对同一块内存多次释放

void main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	free(p);//p=NULL;
	free(p);
}

这种情况再写代码的时候在函数里面释放完之后，回主函数有释放一遍导致错误。最好的解决方法是将释放完的指针立刻置为空指针。

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

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

指针p是一个局部变量，出函数就会被销毁，这样指向动态开辟的地址的指针就会丢失，导致这块内存没有人能找到，但是内存一直被占用。程序循环下去直到内存开辟到不够时崩溃。
这里补充一下动态内存的两种回收方式：

1. 主动释放：利用free函数释放
2. 程序结束自动释放

几个经典的笔试题

1

void Getmemory(char* p)
{
	p = (char*)malloc(100);
}
void test()
{
	char* str = NULL;
	Getmemory(str);
	strcpy(str, "helloworld");
	printf(str);
}

这个代码实际上是错误的
str虽然是指针，但是str传递给Getmemory实际上是值传递，所以Getmemory里的形参是str的一份临时拷贝，Getmemory函数结束就会被销毁。所以str并不会受到影响，str依然是NULL，strcpy函数调用将常量字符串赋给空指针就会出现错误
参考写法：

void Getmemory(char** p)
{
	*p = (char*)malloc(100);
}
void main()
{
	char* str = NULL;
	Getmemory(&str);
	strcpy(str, "helloworld");
	printf(str);
}

改成传指针的地址，并用二级指针接收即可

2

char* Getmemory(void)
{
	char p[] = "hello world";
	return p;
}
void test()
{
	char* str = NULL;
	str = Getmemory();
	printf(str);
}

这里Getmemory看似有返回值，但是要注意的是常量字符串“hello world”是在栈区上开辟的，在函数结束时，这块内存空间就会被销毁。返回地址时没有意义的
参考写法：

char* Getmemory(void)
{
	char *p = (char*)malloc(100);
	strcpy(p, "kksk");
	return p;
}
void main()
{
	char* str = NULL;
	str = Getmemory();
	printf(str);
}

使用动态内存开辟，函数结束后内存就不会返还给操作系统了！

3

void main()
{
	char* p = (char*)malloc(100);
	strcpy(p, "kksk");
	free(p);
	if (p != NULL)
	{
		strcpy(p, "kksk");
		printf(p);
	}
}

free过后内存被释放，但是指针依然保留那块内存的地址，所以在使用指针访问那块内存就属于非法访问了。

c/c++内存开辟

柔性数组

柔性数组的定义

方式一
typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;

方式二：
typedef struct st_type
{
	int i;
	int a[];//柔性数组成员
}type_a;

柔性数组的特点

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

typedef struct s
{
	int i;
	int a[0];//柔性数组成员
}s;
int main()
{
	struct s* p = (struct s*)malloc(sizeof(struct s) + 10 * sizeof(int));//柔性数组的开辟
	if (p == NULL)
		printf("开辟失败");
	else
	{
		for (int i = 0; i < 10; i++)
		{
			*(p->a + i) = i;
		}
	}
	free(p);
	p = NULL;
}

但是学到这里我们发现柔性数组好像没有存在的必要，如果不用柔性数组，上述该如何实现？

struct s
{
	int i;
	int* arr;
};

int main()
{
	struct s* p = (struct s*)malloc(sizeof(struct s));
	if (p == NULL)
		printf("开辟失败");
	else
	{
		p->i = 10;
		int* pc = (int*)malloc(10 * sizeof(int));
		if (pc != NULL)
		{
			p->arr = pc;
			for (int i = 0; i < 10; i++)
			{
				*(p->arr + i) = i;
			}
		}
		free(pc);
		pc = NULL;
	}

	free(p);
	p = NULL;
}

不用柔性数组，这样开辟也是完全可以的，但是申请空间的时候要申请两次（一次是给结构体申请，一次是给数组申请），释放内存的时候也要释放两次。所以这就体现出了柔性数组的好处，如果我们的代码是在一个给别人用的函数中，你里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也要free，所以用柔性数组一次开辟，一次释放十分方便。