C语言动态内存管理

我们目前知道的开辟内存空间的方法有：  1.创建变量   2.创建数组；

但是这2种方法开辟的空间大小都是固定的，如果是数组的话确认了大小之后是无法改变的；

int a=10;//在栈区空间上开辟4个字节的空间；

int arr[10];//在栈区空间上开辟10个整型的空间；

有了动态开辟可以让我们更加灵活的运用内存空间，成为我们有力的武器；

1.malloc和free

malloc这个函数可以让我们指定开辟内存空间的大小，它的参数是size_t的num；这个参数是要开辟的空间多大，单位是字节；它的返回值是开辟好的内存空间的起始地址；

但是，malloc不总是会开辟成功，也会开辟失败，当开辟空间失败它会返回一个空指针的，所以我们在使用的时候一定要去判断它的返回值，不然我们可能会对空指针进行操作；

练习：

利用malloc函数创建一个二维数组；

int main()
{
	int(*arr)[5] = (int (*)[5])malloc(15 * sizeof(int));
	if (arr == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			scanf("%d", &arr[i][j]);
		}
	}
	printf("\n");
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	free(arr);
	arr = NULL;
	return 0;
}

free是和动态内存开辟函数搭配使用的，当我们开辟好一个空间，使用完之后我们不再需要这块空间的时候，要及时将空间回收给操作系统；这个函数就是用来回收动态内存开辟的空间的，它的参数是要回收的那块空间的起始地址；

如果我们给这个函数传空指针的话它什么也不会做，同时，将空间回收之后要把指向那块空间起始地址的指针及时置为空指针，不然会变成野指针；

2.calloc

calloc这个函数用法跟malloc差不多，参数是num个大小为size类型的字节的空间；它如果开辟成功则返回开辟好的空间的起始地址，开辟失败返回空指针；

但是calloc开辟的内存空间会全部初始化为0；用法上和malloc一样；

3.realloc

realloc是用来调整动态开辟内存空间的大小的；参数部分ptr是要调整的那块空间的起始地址；size是调整后的空间的大小；如果开辟成功则返回开辟好的空间的起始位置，失败则返回空指针；

malloc函数开辟空间成功的话返回值有2种情况：

第一种：后面的空间刚好足够新的空间的大小

这个时候会返回旧的起始位置的地址；

第二种：后面容纳不下新增空间的位置

此时realloc就会重新找到一个新的可以容纳的下新空间大小的内存；并把旧的空间的数据先复制到新的空间去，然后再把旧的空间还给操作系统；此时realloc的返回的就是新的空间的地址；

在使用realloc的时候一般创建一个临时的指针变量来接收它的返回值，然后进行判断，如果不为空指针的话就把临时指针变量的值重新赋值给旧的那个指针变量；

举例说明：

int main()
{
	int* pa = (int*)malloc(40);
	if (pa == NULL)
	{
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		pa[i] = i;
	}
	int * ps = (int *)realloc(pa, 20*sizeof(int));
	if (pa == NULL)
	{
		return 1;
	}
	else
	{
		pa = ps;
	}
	//继续使用
	free(pa);
	ps = NULL;
	pa = NULL;
	return 0;
}

我们将新增的空间设置大一点：

 我们可以看到ps和pa的地址是不一样的，这也符合了第二个结论；

realloc的第一个参数如果给它传空指针的话，它的效果和malloc'的效果一样；

以上三个函数所创建的内存空间都是在内存的堆区上的，堆区上的空间只能由我们自己释放空间，或者程序结束后操作系统自己回收；所以在用完这些空间之后要free去释放这些空间，不然如果程序一直运行下去会一直消耗内存；

4.常见的动态内存错误

1.对NULL指针解引用

void test()
{
	int* p = (int*)malloc(INT_MAX / 4);
	*p = 20;//如果p的值是NULL，就会有问题
	free(p);
}
int main()
{
	test();
	return 0;
}

这里是很明显的没有判断函数的返回值，如果函数开辟空间失败的话，我们就是在对空指针进行解引用；

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

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

3.对非动态开辟内存进行释放

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

 这是一定不可以的，free只能释放堆区的内存空间，不能释放在栈区上的空间；

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

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

这也是不行的，free从起始位置开始释放空间；

5.对同一块内存空间重复释放

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

这里我们释放了那一块空间但是p并没有被置为NULL，所以对p而言其实只是单纯有一个地址，但是那块空间已经不属于你了；

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

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

我们在一个函数动态开辟了一块空间，出了函数这块空间并不会自己销毁，但是指针p是一个局部变量，出了作用域就销毁了，这时候我们就再也找不到这块空间的起始地址了，下面还有一个死循环，当程序一直不结束，这就导致了内存泄露的问题；

切记：动态开辟的空间⼀定要释放，并且正确释放。

5.动态内存的经典笔试题目

题目1

void GetMemory(char* p)
{
	p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
}

题目解析：

同时也有内存泄漏的问题;

题目2

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

题目解析:

题目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);
}

这个的错误是没有及时释放动态开辟内存空间,假设程序一直运行,会导致内存泄漏的问题;

题目4

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

题目解析:

6.柔性数组

柔性数组是定义在结构体中,它的大小是不确定的;所以对于柔性数组来说,要使用动态内存给它分配空间;

语法形式:

struct stu
{
	int a;
	int arr[];//这就是柔性数组；
};

//有的编译器可能不支持上面柔性数组的形式
struct stu
{
	int a;
	int arr[0];//这种形式也是柔性数组，大小是不确定的；
};

有几个注意的点:

柔性数组是必须是结构体的最后一个成员;

柔性数组的前面至少有一个成员;

结构体大小不包括柔性数组的大小;

//结构体的大小不包括柔性数组的大小
struct stu
{
	int a;
	int arr[];
};

int main()
{
	printf("%zd", sizeof(struct stu));
	return 0;
}

同时,有柔性数组的结构体也是存在内存对齐的;

柔性数组的使用

int main()
{
	struct stu *ps = (struct stu*)malloc(sizeof(struct stu) + 10 * sizeof(int));
	if (ps == NULL)
	{
		return 1;
	}
	ps->a = 100;
	ps->ch = 'w';
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	free(ps);
	ps = NULL;
	return 0;
}

7.C/C++的内存区域划分

C/C++程序内存分配的⼏个区域：
1. 栈区（stack）：在执⾏函数时，函数内局部变量的存储单元都可以在栈上创建，函数执⾏结束时这些存储单元⾃动被释放。栈内存分配运算内置于处理器的指令集中，效率很⾼，但是分配的内存容量有限。 栈区主要存放运⾏函数⽽分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区（heap）：⼀般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配⽅式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的⼆进制代码