动态内存管理

动态内存管理

1.为什么存在动态内存分配

如果没有动态内存分配，我们能开辟内存的方法无非两种：

int val = 0;//在栈空间上分配四个字节空间
int arr[5] = { 0 };//在栈空间上开辟20个连续字节空间

但是我们如果这样开辟空间，就会有两个特点：

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

但是大多情况，我们所需要的空间并不是固定的，往往是程序跑起来才知道所需要空间，这时候就需要动态内存开辟。

2.动态内存开辟函数介绍

2.1 malloc 和 free

C语言提供了开辟内存的函数：

void* malloc (size_t size);

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

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

内存利用完了还要进行回收，所以C语言还提供了一个free函数，专门进行动态内存的释放和回收，free函数如下;

void free (void* ptr);

另外：

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

二者头文件：

#include <stdilb.h>

代码样例：

#include <stdio.h>
int main()
{
//代码1
int num = 0;
scanf("%d", &num);
int arr[num] = {0};
//代码2
int* ptr = NULL;
ptr = (int*)malloc(num*sizeof(int));
if(NULL != ptr)//判断ptr指针是否为空
{
int i = 0;
for(i=0; i<num; i++)
{
*(ptr+i) = 0；
}
}
free(ptr);//释放ptr所指向的动态内存
ptr = NULL;//防止变成野指针
return 0;
}

2.2 calloc函数

C语言还提供了malloc函数的进阶——calloc函数，可以开辟空间自动初始化为0的函数。

void* calloc (size_t num, size_t size);

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

举个例子：

#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p = (int*)calloc(10, sizeof(int));
if(NULL != p)
{
//使用内存

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

我们来查看内存：

可以观察到开辟的空间都被初始化成0了。
所以我们以后需要初始化的空间时就可以很方便的使用calloc函数完成了。

2.3 reallloc

当我们已经开辟了一块动态内存后，我们又想对这块内存扩容或者缩小，这时候就需要我们的realloc函数了。
realloc函数原型：

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

• ptr 是要调整的内存地址

• size 调整之后新大小

• 返回值为调整之后的内存起始位置。

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

但是我们使用realloc函数时仍然是有限制的，因为需要扩容的空间可能过大而后面又没有那么一大块连续的内存空间。
所以使用realloc函数分为两种情况：

• 情况1：原有空间之后有足够大的空间
  ————>这时就是正常开辟所需空间。原有空间的数据不发生变化。
• 情况2：原有空间之后没有足够大的空间
  原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小
  的连续空间来使用。这样函数返回的是一个新的内存地址。

结合第二种两种情况：
我们举个realloc的陷阱代码：

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
int main() 
{
    int* p = (int*)malloc(2 * sizeof(int));
    int* t = p + 1;
    printf("p的值:%d\n", p);
    printf("t的值:%d\n", t);
    p = (int*)realloc(p, 1000 * sizeof(int));
    printf("p的值:%d\n", p);
    printf("t的值:%d\n", t);
    return 0;
}

编译的结果：

我们看出来，新的p已经跑路的，已经不跟t一起了，但是p还有良心，没有把原来t的数据带走，只是拷贝了一份带走。所以当发生第二种情况时，返回新的首地址，同时也copy了原来数据走。

3.常见的动态内存错误。

3.1 对NULL指针的解引用操作。

这样子系统就保错了。

3.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);
}
int main()
{
	test();
	return 0;
}

编译结果：

3.3 对非动态开辟的空间进行free释放

代码示例：

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

编译结果：

3.4 使用free不完全释放动态开辟的内存

代码示例：

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

编译结果：

3.5 对一块动态开辟的内存多次释放

代码示例：

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

编译结果：

所以不正确释放内存都会导致断点。

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

代码示例：

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

当我们不释放这部分内存后，就会导致这部分内存泄漏了，用不到，又占空间，就是俗称的占着茅坑不拉shi。
所以我们一定要有，谁开辟的内存由谁释放的编程习惯。
同时：
切记：
动态开辟的空间一定要释放，并且正确释放。

4、几道常见的面试题

4.1 题目一

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

运行这段代码结果：

程序崩了，我们查看错误报告，应该看出来是内存问题，答案确实就是内存问题。
我们在Test函数内申请内存时并不是直接申请，而是又做一个申请内存的函数GetMemory来申请，从逻辑上考虑是没问题的，但是我们需要考虑一个函数的生命周期，在GetMemory函数为p开辟空间，当函数结束后，这个内存一样还是被函数给释放还给系统了，所以一样还是没有申请到内存，因此str还是空指针。所以系统内存冲突。

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

运行代码结果：

这次GetMemory函数同样释放了内存，不同的就是这次有了返回值，所以str == p，但是p指向的内存空间已经销毁了，所以这次str不是空指针了，变成了野指针，所以打印了乱码。

4.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);
}
int main()
{
	Test();
	return 0;
}

代码运行结果：

这个是成功的代码，利用二级指针就能避免内存内容销毁的问题，所以成功了，可能唯一的缺点就是没有用free释放用完的内存吧。

4.4 题目四

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函数还是造成了非法访问内存：

5.C/C++的内存开辟

看图–>

详细描述：
C/C++程序内存分配的几个区域：

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

因此static修饰静态变量就是这样的原理：

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

6.柔性数组

柔性数组出现的比较少，所以我们只需要简单了解就好了。
C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。
例：

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

有些编译器比较严格的话我们可以改成：

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

6.1 柔性数组的特点

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

//code1
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;
printf("%d\n", sizeof(type_a));//输出的是4

sizeof返回的只有int 的大小。

6.2 柔性数组的使用

例：

//代码1
int i = 0;
type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));
//业务处理
p->i = 100;
for(i=0; i<100; i++)
{
p->a[i] = i;
}
free(p);

这样就相当于给a 100个int的内存空间

6.3 柔性数组的好处

当我们不使用柔性数组时，我们也一样可以实现代码1：

/代码2
typedef struct st_type
{
int i;
int *p_a;
}type_a;
type_a *p = (type_a *)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;

但是用柔性数组，即代码1可有两个额外好处：

1. 方便内存释放
   如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
2. 这样有利于访问速度
   连续的内存有益于提高访问速度，也有益于减少内存碎片.（或许提升不明显）

以上就是本篇内容，可能结尾有点仓促了。
如有不对的地方，欢迎指正！^_