动态内存开辟函数的使用

你可能看到这个标题的时候是一头雾水，什么是动态开辟，动态开辟有什么应用，怎么实现动态开辟等等一系列的问题。今天这篇文章就带你了解动态内存的开辟。

一.内存分配存在的必要性

通过前面的学习，我们知道已经了解的内存开辟方式有如下两种：

 int a=10;//在栈区开辟了4个字节的空间，并赋值为10

char arr[10]={0};//在栈区开辟了10个字节的空间，并赋值为0

前面这两种方法就是到目前位置我们定义变量和数组的方式，从这里我们可以看出这样的内存分配有两个不足之处：

1.内存空间由操作系统分配，程序员无法自由使用

2.内存空间一旦分配完成，空间固定，无法灵活地变动和按需更改空间的大小！

因此为了能够灵活地使用内存，C语言提供了动态内存分配的能力，使得程序员能够灵活地使内存来设计程序，接下来我们来讲动态内存的使用方式。

2.动态内存的使用---->malloc、calloc、realloc、free函数

C语言提供了4个和动态内存开辟有关的函数：malloc、calloc、realloc、free，下面我们来依次介绍这几个函数的使用：:

1.malloc：对应的函数原型如下：

void *malloc( size_t size );

Allocates memory blocks

从函数原型及解释可以看出，malloc函数的作用主要是开辟一块大小为size的内存块，并记录开辟的空间的首地址！而开辟的空间的内容是随机值！

#include<stdio.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>//malloc函数所在的头文件
//malloc函数的使用
void test()
{
	int* tmp=(int*)malloc(sizeof(int) * 10);
	if (NULL == tmp)
	{
		printf("%s\n", strerror(errno));
		return;
	}
	free(tmp);
	tmp = NULL;
}
int main()
{  
	test();
	return 0;
}

我们打开内存窗口并输入tmp的值，观察上述代码发生了什么事：

可以看到确实开辟了一块空间，空间里的值是随机值！这就是malloc函数的作用，当然，使用malloc函数的时候要注意以下几点：

1.malloc可能申请失败，一旦失败就会返回空指针，所以在使用malloc函数的返回值的时候要检查指针的合法性！

2.malloc函数申请的空间需要用free函数回收，否则会存在内存泄露的问题！

2.calloc:对应的函数原型如下：

void *calloc( size_t num, size_t size );

Allocates an array in memory with elements initialized to 0.

calloc和malloc函数本质上都是动态申请一块连续的空间，但不同的是calloc函数在申请空间的时候会把空间的内容初始化成0。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>//calloc函数所在的头文件
//calloc函数的使用
//void *calloc( size_t num, size_t size );
//第一个参数是初始化空间元素的个数
//第二个参数是初始化空间元素的大小
void test()
{
	int* tmp=(int*)calloc(10, sizeof(int));
	if (NULL == tmp)
	{
		printf("%s\n", strerror(errno));
		return;
	}
   free(tmp);
   tmp=NULL;
}

int main()
{
	test();
	return 0;
}

我们打开内存窗口观察申请的内存空间：

 我们确实看到了calloc确实也申请了一块空间，但和malloc不同的是，calloc把申请的空间的内容全部都初始化成了0!那么使用calloc函数要注意以下的几个地方

1.calloc函数申请空间可能失败，一旦失败calloc返回空指针，所以在使用calloc函数之前要注意判断指针的合法性！

2.calloc申请的空间需要用free函数释放！

3.realloc：来看函数原型：

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

Reallocate memory blocks

realloc函数的功能就是重新分配内存空间，也正是因为有这个函数使得动态内存分配函数变得更加灵活，realloc函数使用的时候有几种情况：

情况一：调整的空间比原来的空间小

这种情况下，realloc函数会丢弃多余的空间，将可使用的空间调整为你指定大小的空间

情况二：调整的空间比原来的空间大

这种情况就比较复杂，具体还要分成两种情况讨论!

1.假设已经开辟的空间的后面的空间足够，那么realloc利用的就是后续的空间，此时返回的还是原来的地址

2.假设后面空间已经不够使用，那么realloc就会重新寻找一块新的空间，拷贝原来的数据到新的空间，并把原来的空间释放！

realloc函数在使用的时候要注意以下几点：

1.realloc可能会失败，返回空指针，所以在使用之前要判断指针的合法性!

2.realloc申请的内存空间需要用free释放，否则存在内存泄露的问题！

4.free函数：先来看函数原型：

void free( void *memblock );

Deallocates or frees a memory block.

这个函数的功能就是释放由malloc、calloc、realloc动态申请的内存空间，使用的方法比较简单：

#include<stdlib.h>
#include<stdio.h>
//free的使用
int main()
{
   int* tmp=(int*)malloc(100);
    free(tmp);
     tmp=NULL;
   return 0;
}

 使用free函数的时候，要注意以下的几个点：

1.free只能释放malloc、realloc、calloc的动态内存函数开辟的内存，使用free释放局部变量的地址的行为是标准未定义的！

2.对于申请的动态内存，如果不及时使用free释放会造成内存泄露！

3.free(NULL)在语法层面是正确的，但没有什么实际意义

4.使用完free函数，要把记录释放位置的指针置空！

简单介绍完了这几个函数，接下来我们来讲讲计算机内存的分布、以及动态内存分配可能出现的常见错误！

三.计算机的内存分布

计算机的内存分布相对复杂，现阶段我们只需了解三大区：栈区、堆区、静态区

栈区：存储局部变量和局部数组等等，特点是创建时由系统自动创建，出作用域时自动销毁！

堆区：由程序员使用动态内存开辟函数申请，使用结束后由程序员手动释放

静态区：存储全局变量、静态变量、常量字符串等等

因为堆区的动态内存的生命周期是在手动释放之前都一直存在，所以有的时候要返回的结果不只是一个值的情况下，我们就可以使用动态开辟的内存存储数据，最后把数据带回来。

正因为动态内存开辟十分的方便和灵活，所以在使用的时候也有很多要注意的问题。

四.动态开辟的易错问题--->笔试题

1.对空指针的解引用操作：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
#include<limits.h>
//对空指针的解引用操作
void test()
{
	int* tmp = (int*)malloc(INT_MAX*sizeof(int));
	for (int i = 0; i < 10; i++)
	{
		*(tmp + i) = i;
		printf("%d ", *(tmp + i));
	}
	free(tmp);
	tmp = NULL;
}
int main()
{
	test();
	return 0;
}

这段代码乍一看好像没有什么大问题，但其实运行起来，程序实际会崩溃！因为我们对空指针进行了解引用操作！为什么会对空指针进行解引用？本质原因就是计算机分配不到那么大的空间给我们

INT_MAX:大小是2147483647,而上面的代码向堆区申请了能够存放这么多个整型元素的空间，但是堆区并没有那么大的空间可以分配，因此申请失败返回NULL指针，而接下来对NULL指针的解引用引发了程序崩溃！

所以，我们在使用动态内存分配函数返回的地址的时候，一定要检查合法性！正确的代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<errno.h>//errno所在的头文件
#include<stdlib.h>
#include<limits.h>
/对空指针的解引用操作
void test()
{
	int* tmp = (int*)malloc(INT_MAX*sizeof(int));
	if (NULL == tmp)//检查指针的合法性！
	{
		printf("%s\n", strerror(errno));//报出错误信息，并停止当前函数
		return;
	}
	for (int i = 0; i < 10; i++)
	{
		*(tmp + i) = i;
		printf("%d ", *(tmp + i));
	}
	free(tmp);
	tmp = NULL;
}
int main()
{
	test();
	return 0;
}

再来看一段经典的对空指针解引用的错误代码，也曾经是一家公司的笔试题！

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<errno.h>//errno所在的头文件
#include<stdlib.h>
#include<limits.h>
void GetMemory(char* p)
{
	p = (char*)malloc(100);
}
void test()
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "helloworld");
	printf(str);
}
int main()
{
	test();
	return 0;
}

这段代码的本意是动态申请100个字节的空间，并让str指向这块动态申请的空间，在使用strcpy函数把helloworld拷贝进去，最后在把拷贝后的结果打印出来，乍一看好像没有什么大问题，但实际程序还是会崩溃！因为str还是空指针！

问题就出在GetMemory函数上，因为这个函数是值传递的，也就是说，p只是str的一份拷贝，对拷贝的修改并不会影响到原来的str，那么strcpy函数的第一个参数是NULL！因此这也就是对NULL指针进行解引用操作！

另外，这段代码还存在内存泄露的问题！由于记录申请空间起始地址的局部变量p在函数调用结束后自动销毁，一旦函数调用结束，我们就没办法获取这块内存的起始位置，那么这块内存我们就不能使用了，内存就泄露了！这是这段代码还存在的一个问题！这段代码有两种解决方案：

方案一：传递str的地址改变str

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<errno.h>//errno所在的头文件
#include<stdlib.h>
#include<limits.h>
void GetMemory(char** p)
{
	*p = (char*)malloc(100);
}
void test()
{
	char* str = NULL;
	GetMemory(&str);
	strcpy(str, "helloworld");
	printf(str);
    free(str);
    str=NULL;
}
int main()
{   
	test();
	return 0;
}

程序运行结果如下：

 

 解决方案二：用返回一个动态申请的指针赋值给str

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<errno.h>//errno所在的头文件
#include<stdlib.h>
#include<limits.h>
char* GetMemory()
{
	char* p = (char*)malloc(100);
	return p;
}
void test()
{
	char* str = NULL;
	str = GetMemory();
   if (NULL == str)
	{
		printf("%s\n", strerror(error));
		return;
	}
	strcpy(str, "helloworld");
	printf("返回值的方式 ：");
	printf(str);
    free(str);
    str=NULL;
}
int main()
{
	test();
	return 0;
}

 这里我们通过使用返回值的方式改变str,同样也可以起到改变str的作用！程序运行结果如下：

 2.返回局部变量的地址

我们知道，局部变量出了作用域就会被销毁，那么有这么一段如下的代码：

int* test()
{
	int a = 10;
	return &a;
}
int main()
{   
	int* pa = test();
	return 0;
}

因为出了函数以后，a的空间被回收了，那么原先指向存放a空间的地址里的内容就是随机的了，所以不要返回局部变量的地址！但是可以返回局部变量的值！返回局部变量的值是正确的行为！

3.动态申请的内存空间使用完没有free释放

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<errno.h>//errno所在的头文件
#include<stdlib.h>
#include<limits.h>
char* GetMemory()
{
	char* p = (char*)malloc(100);
	return p;
}
void test()
{
	char* str = NULL;
	str = GetMemory();
	if (NULL == str)
	{
		printf("%s\n", strerror(errno));
		return;
	}
	strcpy(str, "helloworld");
	printf(str);
}
int main()
{
	test();
	return 0;
}

这段代码是可以正常运行，但这段代码还有不足地地方就是使用完动态分配地内存没有free释放，这样会造成内存泄露导致可用的内存越来越少！正确的代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<errno.h>//errno所在的头文件
#include<stdlib.h>
#include<limits.h>
char* GetMemory()
{
	char* p = (char*)malloc(100);
	return p;
}
void test()
{
	char* str = NULL;
	str = GetMemory();
	if (NULL == str)
	{
		printf("%s\n", strerror(errno));
		return;
	}
	strcpy(str, "helloworld");
	printf(str);
    free(str);
    str=NULL;
}
int main()
{
	test();
	return 0;
}

 这样代码就完美了！以上就是动态内存申请的相关知识点，希望大家共同勉励，继续加油！