动态内存分配
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++程序内存分配的几个区域：
- 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈
上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。- 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
- 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
- 代码段：存放函数体（类成员函数和全局函数）的二进制代码。
柔性数组
定义
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就可以把所有的内存也给释放掉。
第二个好处是：这样有利于访问速度.
连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）
以上是关于动态内存分配的主要内容，如果未能解决你的问题，请参考以下文章