C语言动态内存开辟

Posted 2021-10-21 Ja_king_

动态内存开辟

• • 1.malloc、free
  • • 1.1 malloc的原型为：
    • 1.2 malloc的用法：
    • 1.3 free的原型：
    • 1.4 free的用法：
  • 2.calloc
  • • 2.1 calloc原型:
    • 2.2 calloc用法：
  • 3.realloc
  • • 3.1 realloc原型：
    • 3.2 realloc用法：

1.malloc、free

1.1 malloc的原型为：

void *malloc( size_t size );

1.2 malloc的用法：

看下面代码：

int* p=(int*)malloc(10*sizeof(int));

上面代码意思是开辟10个int类型大小的空间，将其强制转换为int型，并用int类型指针接收。
1.若开辟成功，则返回开辟空间的头指针。
2.若开辟失败，则返回空指针。
所以，用了malloc后一定要判断！
如下面代码：

#include<stdio.h>
#include<stdlib.h>// malloc 所在头文件
#include<errno.h>// errno，h 错误码库
int main()       // 与 函数 strerror（错误信息报告）  搭配使用,将错误码转化为错误信息，并返回它的地址
{
	// 我想向内存申请 10个 整形的 空间
	int* p = (int*)malloc(/*INT_MAX*/10 * (sizeof(int)));// 因为  malloc 函数 返回的是 万能*（无类型）指针，所以需要转化类型
	// malloc 函数 也有 开辟空间失败的时候，
	// 比如 内存 只有 4 个 g ，我要开辟 8 g 空间，这肯定是会失败的，返回 空指针 NULL
	
	if (p == NULL)
	{
		// 找出打印错误原因的方式
		printf("%s\\n", strerror(errno));// malloc(INT_MAX)
		                //输出 Not enough space
	}
	else
	{
		// 正常使用 空间
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p + i) = i;// 赋值 0 1 2 3 4 5 6 7 8 9
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));// 输出 0 1 2 3 4 5 6 7 8 9
		}
		printf("\\n");
	}
	// 当动态申请的空间 不再使用的时候
	// 就会把空间 还给 操作系统
	// 这时候 就会用到 free 函数
	return 0;
}

而malloc的使用需和free一起，即：用malloc开辟一处空间，必须由free来释放。否则会造成内存泄露！

1.3 free的原型：

void free( void *memblock );

1.4 free的用法：

free专门用于动态内存的释放和回收。如下代码：

#include<stdio.h>
#include<stdlib.h>// malloc,free 所在头文件
#include<errno.h>
int main()
{
	// 我想向内存申请 10个 整形的 空间
	int* p = (int*)malloc(10 * (sizeof(int)));
	if (p == NULL)
	{
		// 找出打印错误原因的方式
		printf("%s\\n", strerror(errno));// malloc(INT_MAX)
		                //输出 Not enough space
	}
	else
	{
		// 正常使用 空间
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p + i) = i;// 0 1 2 3 4 5 6 7 8 9
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));// 0 1 2 3 4 5 6 7 8 9
		}
		printf("\\n");
	}
	// 当动态申请的空间 不再使用的时候
	// 就会把空间 还给 操作系统
	// 这时候 就会用到 free 函数
	free(p);// 用完了再释放，也就是说 在打印完之后（调用完之后），再释放（p的值没有改变，还可以通过它找到该空间）
	//  虽然当前空间 不属于当前程序，但是依然 可以通过 p  找到  该空间，很有可能会破坏这个空间
	//  所以先在这个 指针 依然很危险

	p = NULL; // free函数 释放完空间后，不会改 p 的值，所以我们自己主动改
	return 0;
}
// 最后请注意:free 是用来 释放 动态开辟的内存

// free 函数 的 特殊情况：
//1. 如果参数 ptr 指向的空间不是动态开辟的，那 free 函数的行为是未定义的
//2. 如果参数 ptr 是 NULL 指针，则函数 什么 都不做。

1.首先，将动态开辟的空间free掉。
2.再将free掉的空间的头指针制为空即可。

2.calloc

2.1 calloc原型:

void *calloc( size_t num, size_t size );

2.2 calloc用法：

calloc和malloc一样，都用于动态内存开辟，区别点在于calloc具有初始化功能，即：calloc可将开辟的空间进行初始化操作。
如下代码：

 用法跟 malloc 函数差不多
#include<stdio.h>
#include<errno.h>
#include<string.h>
int main()
{                     // 开一块空间，空间大小为 10 * int == 40 字节
	int* p = (int*)calloc(10, sizeof(int));// 比 malloc 函数 多一个元素个数 参数
	if (p == NULL)    
	{
		printf("%s\\n", strerror(errno));
	}
	else
	{
		int i = 0;
		for (i = 0; i < 10; i++)// 因为 p 为整形指针变量，指向一个 int 类型 元素，所以有 10个 int 元素
		{
			printf("%d ", *(p + i));// 0 0 0 0 0 0 0 0 0 0
		}  //calloc 在开辟好空间后，会把空间的所有字节内容全部初始化为 零
	}
	free(p);
	p = NULL;// 狗头拿来！！
	return 0;
}

3.realloc

3.1 realloc原型：

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

3.2 realloc用法：

有时我们会发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，为了合理的使用内存，我们一定会对内存的大小做灵活的调整，realloc函数就可以做到对动态开辟内存大小的调整。
如以下代码：

#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char* argv[], char* envp[])
{
	int input;
	int n;
	int *numbers1;
	int *numbers2;
	numbers1=NULL;
 
	if((numbers2=(int *)malloc(5*sizeof(int)))==NULL)//为numbers2在堆中分配内存空间
	{
		printf("malloc memory unsuccessful");
		exit(1);
	}
	
	printf("numbers2 addr: %8X\\n",(int)numbers2);
 
	for(n=0;n<5;n++) //初始化
	{
		*(numbers2+n)=n;
		//printf("numbers2's data: %d\\n",*(numbers2+n));
	}
 
	printf("Enter new size: ");
	scanf("%d",&input);
 
	//重新分配内存空间，如果分配成功的话，就释放numbers2指针,
	//但是并没有将numbers2指针赋为NULL,也就是说释放掉的是系统分配的堆空间，
	//和该指针没有直接的关系，现在仍然可以用numbers2来访问这部分堆空间，但是
	//现在的堆空间已经不属于该进程的了。
	numbers1=(int *)realloc(numbers2,(input+5)*sizeof(int));
 
	if(numbers1==NULL)
	{
		printf("Error (re)allocating memory");
		exit(1);
	}
	
	printf("numbers1 addr: %8X\\n",(int)numbers1);
 
	/*for(n=0;n<5;n++) //输出从numbers2拷贝来的数据
	{
		printf("the numbers1's data copy from numbers2: %d\\n",*(numbers1+n));
	}*/
 
	for(n=0;n<input;n++)//新数据初始化
	{
		*(numbers1+5+n)=n+5;
		//printf("numbers1' new data: %d\\n",*(numbers1+5+n));
	}
 
	printf("\\n");
 
	free(numbers1);//释放numbers1，此处不需要释放numbers1，因为在realloc()时已经释放
	numbers1=NULL;
	//free(numbers2);//不能再次释放
	return 0;
}

1.如果当前内存段后有足够的空间，realloc()返回原来的指针。
2.如果当前内存段后没有足够的空间，realloc()返回一个新的内存段的指针