动态内存分配

Posted AI_ELF

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了动态内存分配相关的知识,希望对你有一定的参考价值。

常见的动态内存错误

对NULL指针的解引用操作

eg:

#include<stdio.h>
int main()
{
	int* p = (int*)malloc(10000000000);
	int i = 0;
	for (i = 0;i < 10;i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
	return 0;
}

1.如果p的值是NULL,就会有问题
2.对malloc进行判空处理

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

eg:

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(10*sizeof(int));
	if (p == NULL)
	{
		perror("main");
		return 1;
	}
	int i = 0;

	for (i = 0;i < 40;i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
	return 0;
}

当i是10的时候越界访问

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

eg:

int main()
{
	int arr[10] = { 0 };
	int* p = arr;
	free(p);
	p = NULL;
	return 0;
}

使用free对p进行非动态内存的释放
p是局部变量,是在栈上开辟的

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

eg:

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("main");
		return 1;
	}
	int i = 0;
	for (i = 0;i < 5;i++)
	{
		*p++ = i;
	}
	free(p);
	p = NULL;
	return 0;
}

p不再指向动态内存的起始位置,而是从p+4的位置开始释放内存空间
而起始位置到p+4是没有被释放的,这样会产生内存泄漏的问题

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

eg:

int main()
{
	int* p = (int*)malloc(sizeof(100));
	free(p);
	free(p);
	return 0;
}

避免对同一块动态内存多次释放可以用以下方法
将p进行释放后,手动将p置成空指针

int main()
{
	int* p = (int*)malloc(sizeof(100));
	free(p);
	p = NULL;
	free(p);
	return 0;
}

动态开辟内存忘记释放(内存泄漏)

eg:

void test()
{
	int* p = (int*)malloc(sizeof(100));
	if (p == NULL)
	{
		return;
	}
}
int main()
{
	test();
	return 0;
}

动态开辟的空间两种回收的方式:
1.主动用free释放并将该指针手动置为空
2.程序结束

经典的笔试题

eg1:该段代码出现的问题

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;
}

解析:
str传给GetMemory函数的时候是值传递,所以GetMemory函数的形参p是str的一份临时拷贝。
在GetMemory函数内部动态申请空间的地址,存放在p中,不会影响外边str,所以当GetMemory函数结束之后,str依然是NULL。所以strcpy会失败.
当GetMemory函数返回之后,形参p销毁,使得动态开辟的100个字节存在内存泄漏。无法释放。

修改一:

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;
}

这里是引用

修改二:

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;
}

eg 2

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,这样GetMemory 函数的返回地址赋给str,这样访问的内存是有效的。

eg3:说明以下代码出现的问题

例一:

int* f1(void)
{
	int x = 10;
	return &x;
}

解释:
fi函数内部创建的整形是在栈区上创建的出了函数,整形x的空间就还给了操作系统返回的地址是没有实际的意义,如果通过返回的地址,去访问内存就是非法访问内存的。

例二:

int* f2(void)
{
	int* ptr;
	*ptr = 10;
	return ptr;
}

解释:
f2函数内部创建的ptr指针未定义(初始化),造成野指针问题,接下来*ptr = 10;这步系统就会报错。
解决方法:
将ptr初始化或将ptr置成空指针

eg 4

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;
}

解释:
没有将释放str
解决方法:
释放str,将str置成空指针

修改:

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;
}

在这里插入图片描述

eg 5

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;
}

解释:
在Test函数将str释放完之后,如果接下来没有将释放的指针置为空指针,那么将造成越界访问
解决方法:
将释放的指针立刻置为空指针

修改:

void Test(void) 
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	str = NULL;
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}
int main()
{
	Test();
	return 0;
}

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

在这里插入图片描述

有了这幅图,我们可以更好的理解static关键字修饰局部变量了。
实际上普通的局部变量是在栈区分配空间的,栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段(静态区),数据段的特点是在上面创建的变量,直到程序结束才销毁所以生命周期变长。

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

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

柔性数组

定义

C99 中说到,结构中的最后一个元素允许是未知大小的数组,这就叫做『柔性数组』。

例子:

struct S
{
	int n;
	int arr[];//大小未知
};

struct S
{
	int n;
	int arr[0];
};

注:
但在各种编译器中以上两种也许会支持其中一种另一种会报错。

柔性数组的特点:

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

柔性数组的优势

例一:

struct S
{
	int n;
	int arr[0];
};
int main()
{
	struct S* ps =(struct S *)malloc(sizeof(struct S) + 10 * sizeof(int));
	ps->n = 10;
	int i = 0;
	for (i = 0;i < 10;i++)
	{
		ps->arr[i] = i;
	}
	struct S* ptr=(struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
	if (ptr != NULL)
	{
		ps = ptr;
	}
	free(ps);
	ps = NULL;
	return 0;
}

例二:

struct S
{
	int n;
	int *arr;
};
int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
	{
		return 1;
	}
	ps->n = 10;
	ps->arr = (int*)malloc(10 * sizeof(struct S));
	if (ps->arr == NULL)
	{
		return 1;
	}
	int i = 0;
	for (i = 0;i < 10;i++)
	{
		ps->arr[i] = i;
	}
	int* ptr = (int*)realloc(ps->arr, 20 * sizeof(int));
	if (ptr != NULL)
	{
		ps->arr = ptr;
	}
	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;
	return 0;
}

上述 例一 和 例二 可以完成同样的功能,但是 例一 的实现有两个好处:
第一个好处是:方便内存释放
如果我们的代码是在一个给别人用的函数中,你在里面做了二次内存分配,并把整个结构体返回给用户。用户调用free可以释放结构体,但是用户并不知道这个结构体内的成员也需要free,所以你不能指望用户来发现这个事。所以,如果我们把结构体的内存以及其成员要的内存一次性分配好了,并返回给用户一个结构体指针,用户做一次free就可以把所有的内存也给释放掉。
第二个好处是:这样有利于访问速度.
连续的内存有益于提高访问速度,也有益于减少内存碎片。(其实,我个人觉得也没多高了,反正你跑不了要用做偏移量的加法来寻址)

以上是关于动态内存分配的主要内容,如果未能解决你的问题,请参考以下文章

C - 读取文件并将文本放入具有动态内存分配的字符指针

简单动态内存分配实现(附代码)

golang 转到片段以观察运行时行为和内存分配

动态内存分配与静态内存分配

需要有关 C++ 中二维数组的动态内存分配的帮助

删除动态分配的内存