C语言动态分配内存

动态分配内存的由来

我们已经掌握的内存开辟方式有：

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

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

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

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

变量在内存中存储方式如下图：

补充

其实在c99中c语言增加了可以创建变长数组

//可变长数组定义
struct S
{
	char name[20];
	int age
};

int main()
{
	int n = 0;
	scanf("%d", &n);

	struct S arr[n];

	return 0;
}

但是都2021年了还是有很多编译器不支持，比如VS2019

静态内存分配是比较局限的，动态内存分配能满足我们想要多大空间就创建多大空间的需求。

动态内存函数的介绍

malloc()函数

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

void *malloc (size_t size); //size是开辟的字节个数，void *是返回申请空间的起始地址

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

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

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

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>
#include <string.h> //想使用strerror函数
#include <errno.h>//想使用errno

int main()
{
	//向内存申请10个整型的空间
	int *p = (int *)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		//打印错误原因的一个方式
		printf("%s\n", strerror(errno));
	}
	else
	{
		//正常使用空间
		int i = 0;
		for (i = 0; i < 10 ; i++) 
		{
			*(p + i) = i;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	return 0;
}

运行结果

如果我们把这段代码中int *p = (int *)malloc(10 * sizeof(int)); 替换成—> int *p = (int *)malloc(INT_MAX);

#define _CRT_SECURE_NO_WARNINGS

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

int main()
{
	//向内存申请10个整型的空间
	int *p = (int *)malloc(INT_MAX);
	if (p == NULL)
	{
		//打印错误原因的一个方式
		printf("%s\n", strerror(errno));
	}
	else
	{
		//正常使用空间
		int i = 0;
		for (i = 0; i < 10 ; i++) 
		{
			*(p + i) = i;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	return 0;
}

运行结果

free()函数

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

void free(void* ptr)

free函数用来释放动态开辟的内存

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

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

当动态申请的空间不再使用的时候，就应该使用free()还给操作系统。

#include <stdio.h>
#include <stdlib.h>
#include <string.h> //想使用strerror函数
#include <errno.h>//想使用errno

int main()
{
	//向内存申请10个整型的空间
	int *p = (int *)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		//打印错误原因的一个方式
		printf("%s\n", strerror(errno));
	}
	else
	{
		//正常使用空间
		int i = 0;
		for (i = 0; i < 10 ; i++) 
		{
			*(p + i) = i;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
    //当动态申请的空间不再使用的时候
    //就应该还给操作系统
    free(p);
    p = NULL;//空指针是不会随便使用的
	return 0;
}

为什么要在free§下面加上一个p = NULL呢？

是因为运行free§后，虽然这块空间被释放掉了，但p中依然还存放了地址，就好比我们浏览网站关掉后，浏览记录还留着。将p指向空指针可以完全断开和空间的连接。

calloc函数

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

void* calloc(size_t num, size_t size);

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h> //想使用strerror函数
#include <errno.h>//想使用errno

int main()
{
    int* p = (int*)calloc(10, sizeof(int));
    if (p == NULL)
    {
        printf("%s\n", strerror(errno));
    }
    else
    {
        int i = 0;
        for (i = 0; i < 10; i++)
        {
            printf("%d ", *(p + i));
        }
    }
    //free函数是用来释放动态开辟空间的
    free(p);
    p = NULL;
    return 0;
}

运行结果

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

realloc函数

• realloc函数的出现让动态内存管理更加灵活。
• 有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc函数就可以做到对动态开辟内存大小的调整。函数原型如下：

void* realloc (void* ptr, size-t size);

• ptr是要调整的内存地址
• size调整之后新大小
• 返回值为调整之后的内存起始位置。
• 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。

int main()
{
   int* p = (int*)malloc(20);
   if(p == NULL)
   {
       printf("%s\n", strrerror(errno));
   }
   else
   {
         int i = 0;
         for(i=0;i<5;i++)
         {
            *(p+i) = i;
         }
   }
   //就是在使用malloc开辟的20个字节空间
   //假设这里，20个字节不能满足我们的使用了
   //希望我们能够有40个字节的空间
   //这里就可以使用realloc来调整动态开辟的内存
   int* p2 = realloc(p, 40);
   int i = 0;
   for(i=0;i<10;i++)
   {
      printf("%d ", *(p2+i));
   }
   return 0;
}

运行结果

确实又多分配了随机20个字节的空间

realloc函数使用的注意事项

在上面展示realloc功能的代码中，我们注意到我们又定义了一个int* p2来存放使用realloc来调整动态开辟的内存。

那么可不可以不这么麻烦，还使用p，不重新定义个p2来存放调整后的内存呢？

这是不可以的！请看下图：

我们现在开辟的是由p指向的这块橙色空间，但是现在不够了，我想补上一块空间。

如果我想补的空间很小，realloc函数会直接在后边补上一块。如下图

这个时候我们现在使用的空间还是由p指向的内存。

但是如果我现在需要比原来两倍大的空间呢？realloc将现在的空间释放，在有足够大的地方，给你一整块空间（数据也一起考到新的空间里）。如下图

这时返回的新地址与原来存在p里的地址就不相同了。

所以不能使用原先的指针。得用新的变量来接受realloc函数的返回值。

总结

realloc在调整内存空间的是存在两种情况

• 情况1：原有空间之后有足够大的内存空间可以直接追加，则直接追加，后返回p。
• 情况2：原有空间之后没有足够的内存空间可以追加，则realloc函数会重新找一个新的内存区域，开辟新的内存区域，即开辟一块满足需求的空间，并且把原来内存中的数据拷贝过来，释放旧的内存空间，最后返回新开辟的内存空间地址。

判断realloc追加失败的代码

int* ptr = realloc(p, INT_MAX);

if(ptr! = NULL)
{
     p = ptr;
     int i = 0;
     for(i = 5; i < 10; i++)
     {
       *(p + i) = i;
     }
     for (i=0; i < 10; i++)
     {
      printf("%d ", *(p+i));
     }
}
//释放内存
free(p);
p= NULL;
return 0;

对于realloc函数，free函数最后释放的内存是realloc调整后的内存。

补充：realloc可以直接实现与malloc相同的功能，开辟空间。

int *p = realloc(NULL, 40);//malloc(40)
return 0;

常见的动态存错误

第一个问题，对NULL进行解引用操作。

int main()
{
  int *p = (int*)malloc(40);
  //万一malloc失败了，p就被赋值为NULL
  
  *p=0;//错
  
  int i = 0;
  for(i=0;i<10;i++)
  {
      *(P + i) = i;
  }
  free(p);
  p = NULL;
  return 0;
}

这样写的问题是万一malloc失败了，p就被赋值为NULL，空指针，不进行返回值的判断就for循环，循环了一堆非法地址。

当然不能说怕返回空指针就在代码里直接将*p=0。

第二个问题，对动态开辟内存的越界访问。

int *p = (int*)malloc(5 * sizeof(int));
if(p == NULL)
{
   return 0;
}
else
{
   int i = 0;
   for(i = 0; i<10; i++)
   {
      *(p + i) = i;
   }
}
free(p);
p = NULL;
return 0;

明明只有5个元素，但我们强行访问10个。这就不行。

第三个问题，对非动态开辟内存使用free释放。

int a = 10;
int *p = &a;
//...
//对非动态开辟内存使用free释放
free(p);
p = NULL;

return 0;

第四个问题，使用free释放动态开辟内存的一部分。

int *p = (int*)malloc(40);
if(p == NULL)
{
  return 0;
}
int i = 0;
for(i = 0;i< 10;i++)
{
    *p++ = i;//这样写p先使用再加加，并且对p产生改变
}
free(p);
p = NULL;
return 0;

*p++ 这种写法会改变指针的位置。

第五个问题，对同一块动态内存的多次使用

int *p = (int*)malloc(40);
if(p == NULL)
{
   return 0;
}
//使用
//释放
free(p);
//...
free(p);

return 0;

运行结果

为了避免这种情况谁开辟谁回收。

而且free()回收后面一定要写p=NULL。这里再次印证了后加一个p=NULL有多重要。

第六个问题，动态开辟内存忘记释放（内存泄漏）

#include<windows.h>
#include <stdlib.h>
int main()
{
   while(1)
   {
    malloc(1);
    sleep(1000);//让windows睡眠1000ms
   }
   return 0;
}

程序一运行电脑内存占用突然提高。因为我一直用没有回收。

这就会导致内存一直被占用。别的程序也用不上。

忘记释放不再使用的动态开辟的空间会造成内存泄漏。切记：动态开辟的空间一定要释放，并且正确释放。