C语言-动态内存管理详解

已于 2022-04-26 23:31:09 修改
阅读量740 收藏
点赞数
分类专栏： C语言 文章标签： c语言
于 2021-12-22 22:39:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gx714433461/article/details/122052154
版权

为什么存在动态内存分配？

内存可以这样开辟：

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

但是这样的开辟空间方式有两个特点：

1.空间开辟大小是固定的。

2.数组在声明时，必须制定数组的长度，它所需要的内存会在编译时分配。

如果所需空间大小在程序运行时才能确定，那么数组编译时开辟空间的方式就不能应对这样的需求，这时就需要动态内存开辟。

动态内存开辟申请的空间位于堆区:

malloc

void* malloc(size_t size)

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

（1）如果开辟成功，则返回一个指向开辟空间的指针

（2）如果开辟失败，则返回一个NULL指针，因此malloc的返回值必须要做检查

（3）返回值的类型是void* ，因此malloc函数并不知道开辟空间的类型，需要使用者在使用时决定类型

（4）如果参数size为0，malloc的行为是标准未定义的，取决于编译器

free

void free(void* ptr）

free函数用来释放动态开辟的内存：释放的是内存，不是指针，指针并没有被释放，指针仍然指向原来的存储空间。指针是一个变量，只有程序结束时才被销毁。释放了内存空间后，原来指向这块空间的指针还是存在！只不过现在指针指向的内容是垃圾，是未定义的，所以说是垃圾。因此，释放内存后把指针指向NULL，防止指针在后面不小心又被解引用了。

 使用free时要注意：

（1）如果参数p指向的空间不是动态开辟的，那么free函数的行为是未定义的

（2）如果参数p是NULL指针，则函数什么事都不做

malloc和free的头文件都是stdlib.h

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
int main()

{
	int a = 10;
	int* p = &a;

	//free只能free堆上的空间，而&a在栈区，会报错
	free(p);//err

	return 0;
}

calloc

void *calloc(size_t num,size_t size) 

为num个大小为size的元素分配一块内存，并将申请到的每个字节都初始化为零

比较malloc和calloc：

(1)malloc只有一个参数---字节数size，calloc有两个参数---元素个数num、每个元素的字节数size

(2)malloc动态内存申请空间成功后，不会初始化，calloc会将每个字节都初始化为0

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	//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 + i));
	}

	free(p);
	p = NULL;

	return 0;
}

 当把上述代码改成calloc动态内存分配时

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<stdlib.h>
int main()
{
	//int* p = (int*)malloc(40);
	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 + i));
	}

	free(p);
	p = NULL;

	return 0;
}

 因此，如果对申请的内存空间的内容要求初始化，可以使用calloc函数.

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

realloc

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

（1）ptr 是要调整的内存地址

（2）size 调整之后新大小

（3）返回值为调整之后的内存起始位置

（4）这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到“新”的空间

（5）realloc在调整内存空间时存在两种情况

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

                    要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化

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

                   原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来 使用。这样函数返回的是一个新的内存地址。

由于realloc有可能申请失败，返回空指针，就不能直接用原来的指针接收，否则已经保存在原来的空间上的数据就无法维护了，因此需要用新的指针接收新空间地址，如果新空间申请成功，就把新指针赋给原来的指针。 

对于情况1：先申请了40个字节，发现申请的空间不够用时，再申请20个字节

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<stdlib.h>
int main()
{
    //先申请10个int的空间
	int* p = (int*)malloc(10*sizeof(int));
	
	if (p == NULL)
	{
		perror("main");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = 0;
	}

	//这里需要p指向的空间更大，还需要2个int的空间，需要realloc重新调整空间，调整后的大小为12 * sizeof(int)
	int* ptr = realloc(p, 12 * sizeof(int));

	if (ptr != NULL)
	{
		p = ptr;
	}

	//使用申请的内存空间

	//使用完毕释放
	free(p);
	p = NULL;


	return 0;
}

VS2013  F10-监视，p指向的空间之后的空间够存放realloc需要申请的空间时，realloc申请的内存空间会在p申请的内存之后追加，从监视可以看出此时p指向的内存起始地址(0x006c54e0) = ptr指向的内存起始地址(0x006c54e0)

对于情况2：先申请了40个字节，发现申请的空间不够用时，再申请20000个字节

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<stdlib.h>
int main()
{
    //先申请10个int的空间
	int* p = (int*)malloc(10 * sizeof(int));
	
	if (p == NULL)
	{
		perror("main");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = 0;
	}

	//这里需要p指向的空间更大，还需要10000个int的空间，需要realloc重新调整空间,调整后的大小为10010 * sizeof(int)
	int* ptr = realloc(p, 10010* sizeof(int));

	if (ptr != NULL)
	{
		p = ptr;
	}

	//使用申请的内存空间

	//使用完毕释放
	free(p);
	p = NULL;


	return 0;
}

VS2013  F10-监视，p指向的空间之后的空间不够存放realloc需要申请的空间时，realloc在堆上重新申请一块内存空间，从监视可以看出p指向的内存起始地址(0x00b354e0) != ptr指向的内存起始地址(0x00b3b008)

realloc申请空间总结为：空间够申请时直接申请，不够申请时：

（1）重新申请一块空间

（2）原来空间的内容会被拷贝到新空间里面去

（3）释放原来的空间

（4）返回新空间起始地址

当realloc的第一个参数，需要调整的内存的地址为NULL时，realloc就相当于malloc,直接在堆区开辟size个字节大小的空间。如：

int *p = (int*)realloc(NULL,40);

注意

malloc、calloc、realloc申请内存空间时前面都要加强转

常见的动态内存开辟错误

（1）对NULL指针进行解引用

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = malloc(1000000000000000000000);
	*p = 26;
	printf("%d", *p);//error 对指向动态开辟内存的指针解引用时没有判空，造成直接对NULL指针解引用
	free(NULL);
	return 0;
}

报错：

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

#define  _CRT_SECURE_NO_WARNINGS  1
#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 < 40; i++)
	{
		*(p + i) = i;
	}

	free(p);
	p = NULL;

	return 0;
}

异常：

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

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int arr[10] = { 0 };//栈区
	int* p = arr;

	//使用

	free(p);//使用free释放非动态开辟的空间
	p = NULL;

	return 0;
}

报错：堆崩溃

 （4）用free释放动态开辟内存的一部分

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
int main()
{
	int* p = malloc(10 * sizeof(int));

	if (p == NULL)
	{
		return 1;
	}
	int i = 0;

	for (i = 0; i < 5; i++)//指针走到申请的内存空间的中途停下了
	{
		*p++ = i;
	}

	free(p);//释放时，系统不知道p指向的起始位置
	p = NULL;

	return 0;
}

 报错：堆崩溃

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

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<stdlib.h>

int main()
{
	int* p = (int*)malloc(100);
	//使用
	//释放
	free(p);
	
	//释放
	free(p);//重复释放

	return 0;
}

代码未编译之前会提示重复释放：使用未初始化的内存"p"

报错：堆崩溃

 （6）动态开辟内存忘记释放（会造成内存泄漏）

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
void test()
{
	int* p = (int*)malloc(100);
	if (p != NULL)
	{
		*p = 20;
	}

    //忘记释放
}

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

代码运行没有问题，但是，尽管动态开辟的空间有两种回收方式：主动free和程序结束自动释放，但是如果忘记主动free可能会造成内存泄漏，带来严重后果。

动态内存开辟经典笔试题

（1）返回空指针+未主动free

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

void* GetMemory(char* p) 
{
	p = (char*)malloc(100);
}

void test()
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
}
int main()
{
	test();
	return 0;
}

GetMemory传递的是str，str是变量名，是值传递，值传递实参不可改变，由于并没有传递&str，形参p是str的一份临时拷贝，p存放申请的100个字节空间的起始地址，等函数调用完毕后，p被销毁，地址没有传给str，str还是空指针，导致strcpy拷贝失败，GetMemory调用完毕后，p消失了，malloc申请的100个字节地地址就再也找不到了，会造成100个字节的内存泄漏，无法释放。并且也无法打印，因为str是空指针。

 有两种修改方式：

第一种：GetMemory函数返回p，即p动态申请的内存空间的起始地址；主动free释放申请的空间

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

char* GetMemory(char* p) //返回类型改为char*
{
	p = (char*)malloc(100);
	return p;//返回申请的内存空间的起始地址
}

void test()
{
	char* str = NULL;
	str = GetMemory(str);//str指针接收申请的内存空间的起始地址
	strcpy(str, "hello world");
	printf(str);
	free(str);//主动free
	str = NULL;//free后将指针置NULL
}
int main()
{
	test();
	return 0;
}

运行结果

第二种：将malloc开辟的空间的起始地址存放到*p也就是str中，由于返回的空间是堆上的空间，GetMemory函数调用结束后，虽然栈的临时空间被销毁了，但是堆不受影响，因此不需要返回值。不过这时需要用传址的方式传参（&str），相应地，GetMemory的形参也应为二级指针char **p。另外还需要主动free。

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

void GetMemory(char** p) //相应地形参类型改为char**
{
	*p = (char*)malloc(100);
	//由于申请的空间在堆上，所以传址的方式在GetMemory函数调用完毕后无需返回值，因此函数返回类型为void
}

void test()
{
	char* str = NULL;
	GetMemory(&str);//传址的方式传参
	strcpy(str, "hello world");
	printf(str);
	free(str);//主动free
	str = NULL;//free后将指针置NULL
}
int main()
{
	test();
	return 0;
}

（2）返回栈上的地址

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
char* GetMemory()
{
	char p[] = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
int main()
{
	Test();
	return 0;
}

打印结果为

这是由于 GetMemory函数中创建的数组p是在栈上创建的，GetMemory调用结束后，数组p的空间就换给了操作系统，因此返回的地址是没有实际意义的，如果通过返回的地址，去访问内存，就是非法访问内存，所以打印结果是乱码。

修改：在堆上使用动态内存开辟空间，GetMemory需要传参，是因为要free动态内存开辟的空间，这里如果将GetMemory设计成无参数函数，那么就无法free动态内存开辟的空间了(不能在GetMemory函数结尾free，如果free，那么动态申请的内存就会被释放，后面访问str指向的内存空间就是非法访问)

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<stdlib.h>
char* GetMemory(char* p)
{
	p = (char*)malloc(100);//在堆上使用动态内存开辟空间
	p = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory(str);//GetMemory需要传参
	printf(str);
    free(str);//释放动态内存开辟的空间
    str = NULL;
}
int main()
{
	Test();
	return 0;
}

 运行结果如下：

（3）未主动free

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<stdlib.h>
void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);//在堆上创建数组p
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

虽然程序正常运行不会报错，但是没有主动free，会造成内存泄漏。

修改：需要free。

#define  _CRT_SECURE_NO_WARNINGS  1
#include<stdio.h>
#include<stdlib.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);
	free(str);//释放动态内存分配申请的空间
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

玲娜贝儿~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
为啥要动态内存和局部变量
acararduino的博客
12-28 354
先看代码,发现问题 #include <iostream> #include <Windows.h> using namespace std; int * add(int x,int y){ int sum=x+y; return &sum; } int * add1(int x,int y){ int *sum=NULL; sum=new int; ...
程序中的局部变量，全局变量，静态变量，结构体，动态申请的内存，函数，究竟放在哪里？
yychentracy的博客
08-29 1746
在C++中内存分成5个区，分别是堆、栈、全局/静态存储区、常量存储区和代码区； 1、栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区，里面的变量通常是局部变量、函数参数等。 2、堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。 3、全...
C语言动态内存分配（malloc(),free(),calloc(),realloc()）
weixin_50803498的博客
08-04 1336
动态内存开辟、malloc()、calloc()、realloc()、free()、动态内存开辟的流程、动态内存初始化、判断内存是否开辟成功、扩容时的3种情况、free()导致程序崩溃的原因
C语言动态内存管理
最新发布
m0_56821563的博客
10-10 596
栈空间和堆空间的介绍及区别，介绍malloc、calloc和realloc堆空间开辟特点和功能，以及free对开辟空间的释放。
动态内存管理：教你在堆上创建变量，避开栈的销毁打击
m0_53607711的博客
09-16 561
教你在堆上创建变量，避开栈的销毁打击
C语言--指针详解
01-27
C语言中的指针是其核心特性之一，它在编程中起着至关重要的作用，尤其是在处理内存管理和高级数据结构时。本文将深入解析C语言的指针概念及其应用。 首先，理解指针的本质是关键。在C语言中，每个变量都有一个唯一...
c语言-学生信息管理系统
05-13
在这个学生信息管理系统中，C语言被用来处理数据结构、内存管理和文件操作等核心功能。开发者需要熟练掌握C语言的基本语法，如变量定义、流程控制、函数定义以及结构体等，以便构建出高效且稳定的程序。 二、结构体...
C语言 动态内存分配详解
08-30
在编写C程序时，良好的内存管理习惯是至关重要的。此外，使用`malloc`和`calloc`分配的内存块的大小在分配时必须已知，如果需要动态改变数组的大小，可以使用`realloc`函数。然而，`realloc`操作也可能有风险，因为...
C语言 动态内存分配的详解及实例
09-01
C语言中的动态内存分配是程序运行时根据需要分配内存的一种机制，这与静态...在编写涉及大量动态内存分配的C语言程序时，理解并正确使用这些内存管理函数至关重要，因为不当的内存管理可能会导致程序崩溃或性能下降。
C语言--班级成绩管理系统.zip
11-24
《C语言实现的班级成绩管理系统详解》 C语言是一种基础且强大的编程语言，因其简洁的语法和高效性能，常被用于开发系统软件、嵌入式系统以及各种应用程序。在这个项目中，我们关注的是一个使用C语言编写的班级成绩...
[转载]解析C++汇编代码-局部变量空间分配及程序栈操作
spearous的专栏
07-30 1788
解析C++汇编代码局部变量空间分配及程序栈操作                                                 刘强cambest@sohu.com2005年8月18日 [前言]对于一个资深程序员来说，了解我们的程序最底层的运行机制是很重要的。特别是对于C/C++程序员来说，这点显得尤为突出。在很多情况下，知道其底层运行机制对我们理解更深层次
cpp 四种分配内存方法
zhe_csdn的博客
02-25 1033
（1) malloc 函数： void *malloc(unsigned int size) 在内存的动态分配区域中分配一个长度为size的连续空间，如果分配成功，则返回所分配内存空间的首地址，否则返回NULL，申请的内存不会进行初始化。 （2）calloc 函数： void *calloc(unsigned int num, unsigned int size) 按照所给的数据个数和数据类型所占字节数，分配一个 num * size 连续的空间。 calloc申请内存空间后，会自动初始化内存空间为 0，但
c语言malloc可以赋初值么,怎么样为malloc申请的字串赋值
weixin_28828243的博客
05-19 1881
原帖在这里：http://bbs.csdn.net/topics/392139009?page=1#post-402183908原因是本人手太快了，所以重新发出，给各位好心的前辈分值。问题列表：【已了解】那本人该怎么样确定这块地址能否真的被释放了呢？void*free(void*p)：【尚存疑问】1、这个操作返回空，将返回空的函数作为指针函数有什么意义？【尚存疑问】2、void*p是什么概...
cuda学习
weixin_45806592的博客
09-11 648
什么是cuda cuda是带有并行内核的串行代码，全部由c/c++编写，串行代码在host端串行执行，并行内核代码在device短的多线程中执行。 cuda是用于在英伟达gpu上编程的编译器和工具 支持gpu的异构计算 cuda API扩展了c/c++编程语言 快速SIMD并行性 从硬件上提供了高级别的抽象 cuda编程流程 从host端将数据拷贝到device端 呼叫gpu告诉gpu启动 在gpu上运行计算 将计算完后的device上的数据拷贝到host端 kernel是CUDA中一个重要的概念
关于动态申请内存malloc的知识
行走在路上的蜗牛
02-26 8207
关于malloc申请内存的函数一、定义malloc函数是一种分配长度为num_bytes字节的内存块的函数，可以向系统申请分配指定size个字节的内存空间。malloc的全称是memory allocation，中文叫动态内存分配，函数返回的类型是void*类型。void*表示未确定的类型。 C,C++规定，void* 类型可以通过类型转换强制转换为任何其它类型的指针。二、函数声明与使用头文件#...
C语言动态申请内存空间之malloc(),calloc(),realloc()函数
maybcsdn的博客
04-18 9685
C语言动态申请内存空间之malloc(),calloc(),realloc()函数 在C语言中用于动态申请内存空间的函数主要为malloc()函数，calloc()函数，以及realloc()函数，以下主要介绍三个函数的用法，区别以及使用时的注意事项。 malloc()，calloc()，realloc()三个函数均为C语言系统库函数，使用其中之一进行动态申请内存空间时，均需要添加 #include<stdlib.h> 头文件，才能正常使用。 函数用法 void *malloc(siz
C++内存管理
08-17 753
内存的使用规则： 在使用malloc()或new申请空间时，要检查有没有分配空间成功，判断方法是判断指针是否为NULL，如申请一块很大的内存而没有这么大的内存则分配内存会失败； 申请成功后最好是将该内存清空，使用memset()后ZeroMemory()清空，不然存在垃圾
局部变量太大导致栈溢出
热门推荐
unclerunning的博客
07-17 1万+
局部变量太大导致栈溢出问题： 昨天，有同学遇到栈溢出的问题。在做大三小学期项目时，需要一个750x750的矩阵。于是在栈中定义了一个二维数组。为了说明问题，做如下简化： /* 测试环境: window平台 vs2013 */int main() { //占用栈内存，局部变量，太大，栈溢出 double test[750][750]; return 0; } 这看似没有
C语言——动态内存
保护小周ღ的博客
04-14 2551
大家好！我是保护小周，本期为大家带来超详细的C语言——动态内存管理，论动态内存在C++/C中的重要性，学好动态内存约等于看穿了C语言~确定不来看看嘛 ~ 1.为什么存在动态内存 2.动态内存函数的介绍 3.常见的动态内存错误 4.经典笔试题 5.柔性数组 快来跟我一起学习吧！ ......
C语言指针与动态内存管理详解
"动态存储管理-c语言指针知识" 在C语言中，动态存储管理是一项重要的编程技术，它允许程序员在程序运行...理解并熟练掌握这些知识点对于深入理解和编写C语言程序至关重要，特别是涉及到动态内存管理和指针操作的场景。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值