devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言动态内存管理详解_动态内存管理实现 1.内存地址需要4字节或8字节对齐 2.不能使用库函数 3.具有内存

作者：我家小花儿 | 2024-05-19 09:16:31

赞

踩

动态内存管理实现 1.内存地址需要4字节或8字节对齐 2.不能使用库函数 3.具有内存

文章目录

1.为什么存在动态内存分配

我们先来看看我们曾经的静态内存开辟的方式

int main()
{
	int num = 12;//在栈空间上开辟4个字节的空间
	int arr[10] = { 0 };//在栈空间上开辟40个字节的连续空间
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

这样开辟空间的额方式有两个特点
1.空间开辟的大小是固定的
2.数字在申明时，必须指定数组的长度，它所需的内存在编译时分配

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

2.动态内存库函数介绍

2.1 malloc库函数

void* malloc (size_t size);

2.1.1函数讲解

1.函数功能：向内存申请一块连续可用的空间，并返回指向这块空间的指针
2.返回值：如果开辟成功，则返回一个指向开辟好空间的指针；如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查
3.返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定
4.如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器
5.头文件#include<stdlib.h>

2.2 free库函数

void free (void* ptr);

2.2.1函数讲解

1.函数功能：用来做动态内存的释放和回收，即用来释放动态开辟的内存
2.如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的
3.如果参数 ptr 是NULL指针，则函数什么事都不做
4.头文件#include<stdlib.h>

2.2.2代码运用

#include<stdlib.h>
#include<stdio.h>
int main()
{
	//申请
	//int* p = (int*)malloc(40);//向内存申请40个字节的连续空间
	int* p = (int*)malloc(10 * sizeof(int));
	//判断
	int* ptr = p;
	if (p == NULL)
	{
		perror("malloc");//报错
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*ptr = i;
		ptr++;
	}
	//释放
	free(p);
	p = NULL;
	ptr = NULL;
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

2.3 calloc库函数

void* calloc (size_t num, size_t size);

2.3.1函数讲解

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

2.3.2代码运用

#include<stdlib.h>
#include<stdio.h>
int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	//申请40个字节的空间 -> 10个整型
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	//释放
	free(p);
	p = NULL;
	return 0;
}
//calloc = malloc + memset

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

2.3.3 malloc与calloc库函数的区别

我们直接看图：
从上图我们可以看出malloc开辟的空间并不会初始化，而calloc开辟的空间会把每个字节初始化为全0

2.4 realloc库函数

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

2.4.1函数讲解

1.函数功能：对动态开辟内存大小做灵活的调整
2.函数参数：ptr 是要调整的内存地址；size 调整之后新大小
3.返回值：返回值为调整之后的内存起始位置
4.数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间
5.头文件#include<stdlib.h>

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

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

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

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

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

2.4.3代码运用

#include<stdio.h>
#include<stdlib.h>
int main()
{
   //申请
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//增加空间
	int* ptr = (int*)realloc(p, 80);//增加到80个字节的空间
	//当realloc开辟失败时返回的是NULL
	//使用
	if (ptr != NULL)
	{
		p = ptr;
		ptr = NULL;
	}
	for (i = 10; i < 20;i++)
	{
		*(p + i) = i;
	}
	//释放
	free(p);
	p = NULL;
	return 0;
}
//int* p=(int*)realloc(NULL,40) 等价于 int* p = (int*)malloc(40)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

3.常见的动态内存错误

3.1对NULL指针的解引用操作

#include<stdlib.h>
#include<limits.h>
int main()
{
	int* p = (int*)malloc(INT_MAX);
	*p = 12;
	free(p);//p为NULL，不能对其解引用
	p = NULL;
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

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

#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(5);
	if (p = NULL);
	{
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i;
	}
	//申请了5个字节的空间，却访问5个整型也就是20个字节的空间，发生越界访问
	//释放
	free(p);
	p = NULL;
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

3.3对非动态开辟的内存使用free释放

#include<stdlib.h>
int main()
{
	int num = 12;
	int* p = &num;
	//num为局部变量并非动态内存开辟的

	free(p);//释放非动态开辟的内存
	p = NULL;
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

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

#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*p = i;
		p++;
	}
	//释放
	//p++改变了p的值，在释放是p指向的已经不再是动态内存的起始空间
	free(p);
	p = NULL;
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

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

#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i;
	}
	free(p);

	free(p);//重复释放
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

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

#include<stdlib.h>
int* get_memory()
{
	int* p = (int*)malloc(40);
	return p;
}
int main()
{
	int* ptr = get_memory();
	//使用
	//......

	//忘记释放不再使用的动态开辟的空间会造成内存泄漏
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

动态开辟的空间一定要释放，并且正确释放

4.几个经典的笔试题

4.1例题一

#include<stdlib.h>
#include<string.h>
#include<stdio.h>
void GetMemory(char* p)
{
	p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

4.1.1错误分析

4.1.2代码改进

#include<stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
void GetMemory(char** p)
{
	assert(p);//断言
	*p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str);//传址调用
	strcpy(str, "hello world");
	printf(str);
	free(str);//释放
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

4.2例题二

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

4.2.1错误分析

4.3例题三

#include <stdlib.h>
#include <string.h>
#include<stdio.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);
}
int main()
{
	Test();
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

4.3.1错误分析

4.3.2代码改进

#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	assert(str);//断言
	strcpy(str, "hello");
	printf(str);
	free(str);//释放
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

4.4例题四

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}
int main()
{
	Test();
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

4.4.1错误分析

5.C/C++程序的内存开辟


上图就是C/C++程序内存分配的几个区域：

  1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
  2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
  3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
  4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

通过这张图，我们还可以更好的理解static关键字修饰局部变量

实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁所以生命周期变长。

6.柔性数组

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

6.1柔性数组定义方法

方法一：

struct S
{
	int n;
	float s;
	int arr[];//柔性数组成员
};


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

方法二：

struct S
{
	int n;
	float s;
	int arr[0];//柔性数组成员
};

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

两种写法在有些编译器会报错无法编译，报错就换成另一种写法即可

6.2柔性数组的特点

1.结构中的柔性数组成员前面必须至少一个其他成员。
2.sizeof 返回的这种结构大小不包括柔性数组的内存。
3.包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大
小，以适应柔性数组的预期大小。

由图可见结构体的大小就是去掉柔性数组后结构体本身的大小，可见并没有为柔性数组开辟空间

6.3柔性数组的使用

我们直接上代码

struct S
{
	int n;
	float s;
	int arr[];//柔性数组成员
};
int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + sizeof(int) * 4);
	if (ps == NULL)
	{
		return 1;
	}
	ps->n = 88;
	ps->s = 6.6f;
	int i = 0;
	printf("请输入四个数\n");
	for (i = 0; i < 4; i++)
	{
		scanf("%d", &(ps->arr[i]));
	}
	printf("%d\n%f\n", ps->n, ps->s);
	for (i = 0; i < 4; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
	//调整
	struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + sizeof(int) * 10);
	if (ptr == NULL)
	{
		return 1;
	}
	else
	{
		ps = ptr;
	}
	//使用
	printf("请输入新增的六个数\n");
	for (i = 4; i < 10; i++)
	{
		scanf("%d", &(ps->arr[i]));
	}
	printf("调整后的数字\n");
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	//释放
	free(ps);
	ps = NULL;
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53

运行截图：

我们再来自己实现一下柔性数组的功能

struct S
{
	int n;
	float s;
	int* arr;
};

int main()
{
	//申请结构体空间
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
	{
		return 1;
	}
	ps->n = 88;
	ps->s = 6.6f;
	//申请arr成员空间
	int* ptr = (int*)malloc(4 * sizeof(int));
	if (ptr == NULL)
	{
		return 1;
	}
	else
	{
		ps->arr = ptr;
	}
	//使用
	int i = 0;
	printf("请输入四个数\n");
	for (i = 0; i < 4; i++)
	{
		scanf("%d", &(ps->arr[i]));
	}
	printf("%d\n", ps->n);
	printf("%f\n", ps->s);
	for (i = 0; i < 4; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
	//调整
	int* pc = (int*)realloc(ps->arr, 10 * sizeof(int));
	if (pc == NULL)
	{
		return 1;
	}
	else
	{
		ps->arr = pc;
	}
	//使用
	printf("请输入新增的六个数\n");
	for (i = 4; i < 10; i++)
	{
		scanf("%d", &ps->arr[i]);
	}
	printf("调整后的数字\n");
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	//释放
	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69

6.4柔性数组的优势

通过上述运用柔性数组和我们自己实现柔性数组的功能可以看出柔性数组的两个优势
一、方便内存释放

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

二、有利于访问速度

连续的内存有益于提高访问速度，也有益于减少内存碎片。

内存碎片： 就拿用malloc申请两次空间来举例，malloc在第二次申请的空间和上一次申请的空间中间可能会间隔的一片内存空间，这里的空出来的内存空间就叫做内存碎片，看图：

好了今天的内容就到这里了，希望对友友们有所帮助，不妨关注加三连支持一下，后期会持续更新C语言干货！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/592213
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号