C语言之动态内存分配总结

爱吃小料的毛孩子

已于 2022-01-23 21:05:20 修改

阅读量2.5k

点赞数 6

分类专栏： C语言文章标签： c语言开发语言后端

于 2022-01-23 14:46:48 首次发布

本文链接：https://blog.csdn.net/poem_coder/article/details/122647434

版权

C语言专栏收录该内容

15 篇文章 1 订阅

订阅专栏

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

一、为什么存在动态内存分配

以前的空间开辟如：int val = 20;//在栈空间上开辟4个字节

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

这两种开辟空间的方式有两种特点：①空间开辟大小是固定的②数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。这时候就只能试试动态存开辟了（堆区）。

二、动态内存函数的介绍

1.malloc和free

malloc:

void *malloc( size_t size );

（1）这个函数向内存申请一块连续可用的空间

（2）引用头文件<stdblb.h>或者<malloc.h>

（3）如果开辟成功，则返回一个指向开辟好空间的指针；如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查

（4）返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。

（5）如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。(malloc(0)是允许的，也会返回一个指针，只是没有空间所以不可使用而已。)

free:

void free( void *ptr );

（1）这个函数专门是用来做动态内存的释放和回收的

（2）引用头文件<stdblb.h>或者<malloc.h>

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

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

#include <stdlib.h>
int main()
{
    int* p = (int*)malloc(40);//申请一块空间，如果申请开辟的空间过大，如40亿，此时会开辟失败
    int i;

    if(p == NULL)//检查malloc的返回值
    {
        return -1;
    }
    for(i = 0; i < 10; i++)//使用开辟的这块空间
    {
        *(p + i) = i;
    }
    free(P);//释放空间,但是此时p仍然可以找到这块空间，p为野指针，这是一个十分危险的行为，所以我们要把p赋值为空指针
    p = NULL;

    return 0;
}

2.calloc

void *calloc( size_t num, size_t size );

（1）引用头文件<stdblb.h>或者<malloc.h>

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

3.realloc

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

（1）引用头文件<stdblb.h>或者<malloc.h>

（2）该函数是对动态开辟内存大小的调整。

（3）ptr 是要调整的内存地址；size 调整之后新大小；返回值为调整之后的内存起始位置；

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

（5）调整空间时的两种情况：

①原有空间之后有足够大的空间。此时直接在原有内存之后直接追加空间，原来空间的数据不发生变化

②原有空间之后没有足够大的空间。此时我们可以在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
int main()
{
	int* p = (int*)calloc(10, sizeof(int));
    int i;

	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
        return -1;
	}
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}

	int* ptr =(int*)realloc(p, 20 * sizeof(int));//空间不够，增加空间至20个int

	if (ptr != NULL)
	{
		p = ptr;
	}
	else
	{
		return -1;
	}
	for (i = 10; i < 20; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 20; i++)
	{
		printf("%d ", *(p + i));//打印
	}
	free(p);//释放空间
	p = NULL;

	return 0;
}

三、常见的动态内存错误

1.对NULL指针进行解引用操作

#include <stdlib.h>
int main()
{
    int* p = (int*)malloc(20);

    //*p = 20;//这样做是有风险的，如果空间开辟失败：p为空指针，不可以对空指针进行解引用
    //正确解法：
    if (p == NULL)
	{
		return -1;
	}
	*p = 20;

	return 0;
}

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

#include <stdlib.h>
int main()
{
	int* p = (int*)malloc(200);
    int i;

	if (p == NULL)
	{
		return -1;
	}
	for (i = 0; i < 80; i++)//顶多50，此处越界访问
	{
		*(p + i) = i;
	}
	free(p);//释放
	p = NULL;

	return 0;
}

由于越界访问，该程序会崩溃

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

#include <stdlib.h>
int main()
{
	int a = 10;
	int* p = &a;

	free(p);//error
	p = NULL;

	return 0;
}

该程序会崩溃。

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

#include <stdlib.h>
int main()
{
    int *p = (int *)malloc(100);
    p++;
    free(p);//p不再指向动态内存的起始位置

    return 0;
}

该程序会崩溃。

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

#include <stdlib.h>
int main()
{
    int *p = (int *)malloc(100);
    free(p);
    free(p);//重复释放

    return 0;
}

该程序会崩溃。

6.动态内存开辟忘记释放（内存泄漏）

在堆区上申请的空间有两种回收的方式:1.主动free 2.当程序退出时，申请的空间也会回收

如果不释放空间，容易出现机器卡顿的情况

四、一些经典题

#include <stdio.h>
#include <string.h>
#include <stdlib.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;
}

该程序会崩溃，因为str传给p的时候是值传递（传变量的地址过去，与变量关联起来才叫址传递；不是说传一个指针上去就是传址），p是str的临时拷贝，所以当malloc开辟的空间起始地址放在p中时，不会影响str，str依然为NULL，当str是NULL，strcpy想把hello world拷贝到str指向的空间时，程序就崩溃了，因为NULL指针指向的空间是不能直接访问的。并且，这个题目还没有释放空间，存在内存泄漏的问题。

可以这样修改：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//修改一：址传递
void GetMemory(char** p)
{
	*p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str);
	strcpy(str, "hello world");
	printf(str);
	
	free(str);
	str = NULL;
}
//修改二：
char* GetMemory(char* p)
{
	p = (char*)malloc(100);
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory(str);
	strcpy(str, "hello world");
	printf(str);

	free(str);
	str = NULL;
}
int main()
{
	Test();

	return 0;
}

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

    return 0;
}

编译并运行该代码，输出如下：

可以看到输出了一段随机值，是因为出了GetMemory函数时，p被销毁，p的这块空间已经不属于我们

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void Test(void) 
{
    char *str = (char *) malloc(100);
    strcpy(str, "hello");
    free(str);//空间释放，这块空间的使用权限已经不是我们的了，此时str为野指针，但是仍然指向hello
    if(str != NULL)
    {
        strcpy(str, "world");//非法访问内存
        printf(str);
    }
}
int main()
{
   Test();

   return 0;
}

此代码虽然可以打印world,但本质上来说，此代码是错的。我们可以在free(str);后面加上一条代码：str = NULL;。

五、C/C++程序的内存开辟

C/C++ 程序内存分配的几个区域：

1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

2. 堆区（heap）：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。分配方式类似于链表。

3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。

4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

六、柔性数组

1.C99中，结构中的最后一个元素允许是未知大小的数组，这就叫做柔性数组成员。如：

//写法一：
typedef struct st_type
{
    int i;
    int a[0];//柔性数组成员
}type_a;
//写法二：
typedef struct st_type
{
    int i;
    int a[];//柔性数组成员
}type_a;

不同的编译器支持的写法不同，写法一不行就用写法二，写法二不行就用写法一

2.柔性数组的特点：

（1）结构中的柔性数组成员前面必须至少一个其他成员。

（2）sizeof 返回的这种结构大小不包括柔性数组的内存。

#include <stdio,h>
struct st_type
{
    int i;
    int a[0];
};
int main()
{
    printf("%d\n", sizeof(struct st_type));//4

    return 0;
}

（3）包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

3.柔性数组的使用：

#include <stdio,h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
struct st_type
{
    int i;
    int a[0];
}type_a;
int main()
{
    int i;
    struct st_type st;//error，没有为柔性数组开辟空间
    struct st_type* ps = (struct st_type*)malloc(sizeof(struct st_type) + 10 * sizeof(int));//malloc返回的是开辟的空间的地址
//                                                     4                         40     (如下图）
    if(ps == NULL)
    {
        printf("%s\n",strerror(errno));
        return -1;
    }
    ps->i = 100;
    for(i = 0; i < 10; i++)
    {
        ps->a[i] = i;
    }
    struct st_type* ptr = realloc(ps, sizeof(struct st_type) + 20*sizeof(int));//扩容
    if(ptr == NULL)
    {
         return -1;
    }
    else
    {
         ps = ptr;
    }
    ......
    free(ps);
    ps = NULL;

    return 0;
}

4.柔性数组的优势：

其实上述代码还有另一种写法：

#include <stdio,h>
#include <string.h>
#include <stdlib.h>
struct st_type
{
	int i;
	int* a;
};
int main()
{
	struct st_type* ps = (struct st_type*)malloc(sizeof(struct st_type) + 10 * sizeof(int));
	ps->i = 100;
	ps->a = (int*)malloc(10 * sizeof(int));
	int i;

	for (i = 0; i < 10; i++)
	{
		ps->a[i] = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->a[i]);
	}
	
	int* ptr = realloc(ps->a, 20 * sizeof(int));//a数组空间不够，希望调整为20个整型数据
	if (ptr == NULL)
	{
		printf("扩容失败\n");
		return -1;
	}
	else
	{
		ps->a = ptr;
	}
	//使用......
	free(ps->a);
	ps->a = NULL;
	free(ps);
	ps = NULL;

	return 0;
}

虽然两种写法的代码实现的功能相同，但是第一种写法有两种好处：

（1）方便内存释放：如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

（2）这样有利于访问速度：连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）

爱吃小料的毛孩子

关注

6
点赞
踩
40

收藏

觉得还不错? 一键收藏
0
评论
C语言之动态内存分配总结

目录一、为什么存在动态内存分配二、动态内存函数的介绍1.malloc和free2.calloc3.realloc三、常见的动态内存错误1.对NULL指针进行解引用操作2.对动态开辟空间的越界访问3.对非动态开辟内存使用free释放4.使用free释放一块动态开辟内存的一部分5.对同一块动态内存多次释放6.动态内存开辟忘记释放（内存泄漏）四、一些经典题五、C/C++程序的内存开辟六、柔性数组一、为什么存在动态内存分配以前的空间开辟如：int.
复制链接

扫一扫