动态内存管理

目录

前言

一、 为什么存在动态内存分配

二、动态内存函数的介绍

1.malloc和free

2.calloc

3.realloc

三、常见的动态内存错误

四、几个经典的笔试题

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

六、柔性数组

1.柔性数组的特点

2.柔性数组的优势

总结

---

前言

  本篇文章主要讲关于动态内存管理的内容。对于空间的需求，有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。这时我们便要用到动态内存，下面我们就开始吧~

---

一、 为什么存在动态内存分配

我们之前所掌握的内存开辟方式有：

int val = 20;//在栈空间上开辟四个字节

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

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

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

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。这时候就只能试试动态存开辟了。

二、动态内存函数的介绍

1.malloc和free

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

void* malloc (size_t size);

//返回开辟空间的

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

• 如果开辟成功，则返回一个指向开辟好空间的指针。
• 如果开辟失败，则返回一个 NULL 指针，因此 malloc 的返回值一定要做检查。
• 返回值的类型是 void* ，所以 malloc 函数并不知道开辟空间的类型，具体在使用的时候使用者自己

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

我们来举个例子：

int main()
{
    //如果我们要存十个整型
    int a[10] = { 0 };

    //如果我们用动态内存开辟
    int* p = (int*)malloc(40);
    //malloc返回值为void*，需要强制类型转换。一个整型是4个字节，十个也就是40个字节
    if (p == NULL)//判断是否开辟成功
    {
        perror("malloc");
        return 1;
    }
    
    //········
    return 0;
}

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

void free (void* ptr);

free 函数用来释放动态开辟的内存，也就是把开辟的空间的使用权还给操作系统。

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

 malloc和free都声明在 stdlib.h 头文件中。

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int num = 0;
	scanf("%d", &num);
	
	int* 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;//注意：free之后，ptr变成野指针，需赋值为空指针，防止后续使用出错。
	return 0;
}

2.calloc

C 语言还提供了一个函数叫 calloc ， calloc 函数也用来动态内存分配。原型如下：

void* calloc (size_t num, size_t size);

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

我们来举一个例子：

#include <stdio.h>
#include<stdlib.h>
int main()
{
	int* ptr = (int*)malloc(4 * sizeof(int));
	if (NULL == ptr)//判断ptr指针是否为空
	{
		perror("malloc");
		return 1;
	}
	free(ptr);//释放ptr所指向的动态内存
	ptr = NULL;

	int* p = (int*)calloc(4, sizeof(int));
	if (NULL == p)//判断p指针是否为空
	{
		perror("calloc");
		return 1;
	}
	free(p);//释放p所指向的动态内存
	p = NULL;
	return 0;
}

我们来进行一下调试，首先看ptr所指向的空间，里面的值是未定义的。

 我们再看p所指向的空间，我们可以看到已全部初始化为0。

 所以如果我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloc函数来完成任务。

3.realloc

有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时

候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小

的调整。

函数原型如下：

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

• realloc 函数的出现让动态内存管理更加灵活。
• ptr 是要调整的内存地址
• size 调整之后新大小
• 返回值为调整之后的内存起始位置。如果没有足够的空间，返回NULL。
• 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。
• realloc 在调整内存空间的是存在两种情况：

1. 情况 1 ：原有空间之后有足够大的空间
2. 情况 2 ：原有空间之后没有足够大的空间

下面我们来画图讲解这两种情况：

 注意：如果内存中找不到任何足够的空间开辟，会返回NULL，为了防止原数据丢失，我们一般会临时创建一个指针。判断不为空时将其赋给原指针。如下：

#include <stdio.h>
#include<stdlib.h>
int main()
{
	int* ptr = (int*)malloc(40);
	if (NULL == ptr)
	{
		perror("malloc");
		return 1;
	}

	int* p = (int*)realloc(ptr,80);
	if (NULL != p)
	{
		ptr = p;
	}
	free(ptr);
	ptr = NULL;
	return 0;
}

三、常见的动态内存错误

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

void test()

{

        int *p = (int *)malloc(INT_MAX/4);

        *p = 20;//如果p的值是NULL，就会有问题

        free(p);

}

解决办法：对malloc返回值进行判空操作。

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.对非动态开辟内存使用free释放

void test()

{

        int a = 10;

        int *p = &a;

        free(p);//p并不是动态内存开辟的，不能使用free。a由编译器释放。

}

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

void test()

{

        int *p = (int *)malloc(100);

        p++;

        free(p);//p不再指向动态内存的起始位置

}

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

void test()

{

        int *p = (int *)malloc(100);

        free(p);

        free(p);//重复释放

}

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

void test()

{

        int *p = (int *)malloc(100);

        if(NULL != p)

        {

                *p = 20;

        }

}//在此处未使用free释放，函数调用结束之后，没有人记得p，无法释放，造成内存泄漏。只申请不释放，不断蚕食内存空间。

int main()

{

        test();

        while(1);

}

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

四、几个经典的笔试题

下面我们来看几道笔试题，更好的了解关于动态内存的知识。

题目1：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

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

请问运行代码会有什么结果？

答：什么都不打印。str是一个指针变量，p也是一个指针变量，p是str的一份临时拷贝，GetMemory函数运行结束后，没有进行释放，造成内存泄漏。且p销毁，没有人记得新开辟空间的地址，str依旧是空指针。且使用strcopy时对空指针解引用，非法访问内存，程序崩溃。

题目2：

#include <stdio.h>
#include<stdlib.h>

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

请问代码运行会有什么结果？

答：打印结果未知。hellow world是在函数内部创建的临时变量，出函数会被回收，p指的是h的地址，返回给str，但是地址所指向的空间已经被回收，str为野指针，所指向空间内容未知。

题目3：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

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

请问代码运行会有什么结果？

答：打印hello。但是没有释放，应在Test函数最后free(str);str = NULL;

题目4：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

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(str)之后，str变为野指针，strcpy时对野指针解引用，程序崩溃。

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

 C/C++程序内存分配的几个区域：

1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结

束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是

分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返

回地址等。

2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分

配方式类似于链表。

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

4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

有了这幅图，我们就可以更好的理解在《 C 语言初识》中讲的 static 关键字修饰局部变量的例子了。

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

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

六、柔性数组

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。

C99 中，结构中的未知大小的数组，，这就叫做『柔性数组』成员。

#include <stdio.h>

struct S1
{
	int num;
	double d;
	int arr[];//最后一个成员是未知大小的数组，称为柔性数组成员
};
//有血编译器会报错无法编译可以改成：
struct S2
{
	int num;
	double d;
	int arr[0];//0不表示0个元素，表示未知大小，也是柔性数组成员
};
int main()
{
	return 0;
}

1.柔性数组的特点

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

#include <stdio.h>

struct S
{
	int num;//柔性数组前至少一个其他成员
	int arr[];
};
int main()
{
	printf("%d", sizeof(struct S));//输出是4，不包括柔性数组的内存
	return 0;
}

柔性数组成员的结构用malloc ()函数进行内存的动态分配。 

#include <stdio.h>
#include <stdlib.h>
struct S
{
	int num;
	int arr[];
};
int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
    //sizeof(struct S)是为num开辟的空间，10 * sizeof(int)是为arr开辟了10个整型空间
	ps->num = 100;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	//释放
	free(ps);
	ps = NULL;
	return 0;
}

2.柔性数组的优势

 我们可以看到使用柔性数组和不使用柔性数组，都能实现相似的功能，那么柔性数组有什么优势呢？

• 好处一：方便内存释放

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

• 好处二：这样有利于访问速度

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

---

总结

  以上就是今天要讲的内容，关于动态内存管理的内容就全部结束了，希望对大家有所帮助，如有问题欢迎评论指出，会积极改正！！谢谢~