动态内存分辟

最新推荐文章于 2024-05-19 14:18:27 发布

SeriousMonkey

最新推荐文章于 2024-05-19 14:18:27 发布

阅读量24

点赞数

文章标签： c语言

本文链接：https://blog.csdn.net/qq_59765917/article/details/133847149

版权

本章重点

为什么存在动态内存分辟
动态内存函数的介绍
1.malloc
2.free
3.calloc
4.realloc
常见的动态内存错误

为什么存在动态内存分配

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

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

上述的开辟空间的方式有两个特点：
1.空间开辟大小时固定的
2.数组在声明时，必须指定数组的长度，在所需要的内存在编译时分配

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

动态内存函数的介绍

malloc、free、calloc、realloc动态内存开辟是在堆区上开辟的

1.malloc和free函数

malloc原型： void* malloc (size_t size)
size表示开辟的字节数，即开辟的大小
头文件是stdlib.h
作用：这个函数向内存申请一块连续的空间，并返回指向这块空间的指针
1.如果开辟成功，则返回一个指向开辟好空间的指针
2.如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做好检查
3.返回值类型是void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定
4.如果size为0，malloc的行为是标准是未定义的，取决于编译器
C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的

int main()
{
    //假设开辟10个整形空间的 - 10*sizeof(int)
    int arr[10];//栈区
    //动态内存开辟
    void* p = malloc(10 * sizeof(int));
    return 0;
}

以上代码需要改进的地方是：1.malloc的返回值是void * 空指针是不能直接解引用的，前面我们说过malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定，这里是需要开辟10个整形空间，所以将返回值设置成int* 更合适。即：

int main()
{
    //假设开辟10个整形空间的 - 10*sizeof(int)
    int arr[10];//栈区
    //动态内存开辟
   int* p = (int*)malloc(10 * sizeof(int));
    return 0;
}

这里之所以将malloc函数强制类型转换成int * 是因为malloc默认返回类型是void* 的在有些编译器中将其赋给整形指针会出现警告

如何使用这些空间

#include<stdlib.h>
int main()
{
//假设开辟10个整形空间的 - 10sizeof(int)
//动态内存开辟
int p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
{
perror(“main”);
return 0;
}
//使用
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
printf("%d ", p[i]);
}
//回收空间
free§;//不会把p的内容设置成NULL
p = NULL;
return 0;
}

细节：
free函数会释放掉创建的空间，但不会将p指针的内容设置成NULL空指针，p依然保存的是开辟时p的地址，这样存在风险，我已经把这个空间释放了又使用p指针去找这块空间就造成了非法访问。
在C语言中，当一个指针不再指向一个有效的内存地址时，我们称这个指针为“悬挂指针”或“空闲指针”。
例如，如果你动态分配了内存，然后释放了它，你可能会得到一个悬挂指针。如果你试图再次使用或访问这个指针，你的程序可能会崩溃，因为你正在试图访问一个不再属于你的内存空间。

并且malloc函数会初始化元素为随机值

C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的
free原型：void free(void* ptr);
ptr是开辟空间的起始地址
如果参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的。比如：

int main()
{
    int a = 1;
    int* p = &a;
    free(p);//err
    return 0;
}

这里存在错误，p指向的是a,a是在栈区上开辟的导致free函数的行为是未定义的

如果参数ptr是NULL指针，则函数什么事都不做
函数声明依然在stdlib.h文件中

2.calloc函数

calloc原型：

void* calloc(size_t num, size_t size)

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

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if(p == NULL)
	{
		return 1;
	}
	int i = 0;
	for(i=0; i<10; i++)
	{
		printf("%d\n",*(p+1));
	}
	free(p);
    p=NULL;
   return 0;
}

在这里插入图片描述

realloc函数

realloc原型：
void* realloc (void* ptr, size_t size);
作用：对动态开辟内存大小的调整
ptr是要调整的内存地址，size是调整之后的大小，返回值为调整之后的内存起始地址，这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间
realloc在调整内存空间存在两种情况：
1.原有空间之后有足够大的空间
在这里插入图片描述
直接返回旧的地址，即：p的地址

2.原有空间之后没有足够多的空间时，扩展的方法是：在堆空间另找一个连续的空间来使用，这样函数的使用就要注意一些
在这里插入图片描述
当后面空间不够后重新寻找另外一块足够空间开辟并且是重新开辟好的空间，然后将原空间的内容复制到新空间，返回新空间的起始地址

#include<stdio.h>
#include<stdlib.h>
int main()
{
        //假设开辟10个整形空间的 - 10*sizeof(int)
        //动态内存开辟
        int* p = (int*)calloc(10 , sizeof(int));
        if (p == NULL)
        {
            perror("main");
            return 0;
        }
        //使用
        int i = 0;
        for (i = 0; i < 10; i++)
        {
            *(p + i) = 5;
        }
	    //这里需要p指向的空间更大，需要20个int的空间
	    //realloc调整空间
	    int* ptr = realloc(p,20*sizeof(int))
			if(ptr != NULL)
			{
				p = ptr;
			}
        //回收空间
        free(p);//不会把p的内容设置成NULL
        p = NULL;
        return 0;
}

如果是新地址，为什么不能拿原空间的p接受？
realloc有可能找不到合适的空间来调整大小，realloc函数会返回空指针NULL。再把空指针赋给原空间后，导致p不能访问原空间，所以不能把realloc返回值直接给原空间

#include<stdio.h>
#include<stdlib.h>
int main()
{
	   //这里的功能类似于malloc，就是直接在堆区开辟40个字节
       int* p = (int*)realloc(NULL, 40)
        return 0;
}

常见的动态内存错误

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

#include <stdio.h>
#include<stdlib.h>
int main()
{
   int* p = (int*)malloc(1000000000);
   int i = 0;
	//这里没有对malloc的返回值做判断
	for(i=0; i<10; i++)
	{
		//err
		*(p+i) = 1;
	}
   return 0;
}

2.对动态开辟空间的越界访问

#include <stdio.h>
#include<stdlib.h>
int main()
{
   int* p = (int*)malloc(10*sizeof(int));
   int i = 0;
	//对malloc的返回值做判断
	if(p == NULL)
	{
		return 1;
	}
	//越界访问，申请的是10个整形空间
	for(i=0; i<40; i++)
	{
		*(p+i) = 1;
	}
	free(p);
	p == NULL;
   return 0;
}

3.对非动态开辟内存使用free释放

#include <stdio.h>
#include<stdlib.h>
int main()
{
   int arr[10] = {0};
	int* p = arr;
	//使用free释放非动态开辟的空间
	free(p);
	p == NULL;
   return 0;
}

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

#include <stdio.h>
#include<stdlib.h>
int main()
{
   int* p = (int*)malloc(10 * sizeof(int));
	if(p == NULL)
	{
		return 1;
	}
	int i = 0;
	for(i=0; i<10; i++)
	{
		//p++往后走不是起始地址了
		*p++ = i;
	}
	free(p);
	p == NULL;
   return 0;
}
}