C语言之动态内存分配总结
目录
一、为什么存在动态内存分配
二、动态内存函数的介绍
1.malloc和free
2.calloc
3.realloc
三、常见的动态内存错误
1.对NULL指针进行解引用操作
2.对动态开辟空间的越界访问
3.对非动态开辟内存使用free释放
4.使用free释放一块动态开辟内存的一部分
5.对同一块动态内存多次释放
6.动态内存开辟忘记释放（内存泄漏）
四、一些经典题
五、C/C++程序的内存开辟
六、柔性数组
一、为什么存在动态内存分配
以前的空间开辟如：int val = 20;//在栈空间上开辟4个字节
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间
这两种开辟空间的方式有两种特点：①空间开辟大小是固定的②数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。 这时候就只能试试动态存开辟了（堆区）。
二、动态内存函数的介绍
1.malloc和free
malloc:
void *malloc( size_t size );
（1）这个函数向内存申请一块连续可用的空间
（2）引用头文件
（3）如果开辟成功，则返回一个指向开辟好空间的指针；如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查
（4）返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
（5）如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。(malloc(0)是允许的，也会返回一个指针，只是没有空间所以不可使用而已。)
free:
void free( void *ptr );
（1）这个函数专门是用来做动态内存的释放和回收的
（2）引用头文件
（3）如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的
（4）如果参数 ptr 是NULL指针，则函数什么事都不做
#include
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）引用头文件
（2）函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0
3.realloc
void *realloc( void *ptr, size_t size );
（1）引用头文件
（2）该函数是对动态开辟内存大小的调整。
（3）ptr 是要调整的内存地址；size 调整之后新大小；返回值为调整之后的内存起始位置；
（4）这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间
（5）调整空间时的两种情况：
①原有空间之后有足够大的空间。此时直接在原有内存之后直接追加空间，原来空间的数据不发生变化
②原有空间之后没有足够大的空间。此时我们可以在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址
#include
#include
#include
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
int main()
{
int* p = (int*)malloc(20);
//*p = 20;//这样做是有风险的，如果空间开辟失败：p为空指针，不可以对空指针进行解引用
//正确解法：
if (p == NULL)
{
return -1;
}
*p = 20;
return 0;
} 2.对动态开辟空间的越界访问
#include
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
int main()
{
int a = 10;
int* p = &a;
free(p);//error
p = NULL;
return 0;
} 该程序会崩溃。
4.使用free释放一块动态开辟内存的一部分
#include
int main()
{
int *p = (int *)malloc(100);
p++;
free(p);//p不再指向动态内存的起始位置
return 0;
} 该程序会崩溃。
5.对同一块动态内存多次释放
#include
int main()
{
int *p = (int *)malloc(100);
free(p);
free(p);//重复释放
return 0;
} 该程序会崩溃。
6.动态内存开辟忘记释放（内存泄漏）
在堆区上申请的空间有两种回收的方式:1.主动free 2.当程序退出时，申请的空间也会回收
如果不释放空间，容易出现机器卡顿的情况
四、一些经典题
1.
#include
#include
#include
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
#include
#include
//修改一：址传递
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;
}
2.
#include
#include
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的这块空间已经不属于我们
3.
#include
#include
#include
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++程序的内存开辟
六、柔性数组
1.C99中，结构中的最后一个元素允许是未知大小的数组，这就叫做柔性数组成员。如：
//写法一：
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;
//写法二：
typedef struct st_type
{
int i;
int a[];//柔性数组成员
}type_a;不同的编译器支持的写法不同，写法一不行就用写法二，写法二不行就用写法一
2.柔性数组的特点：
#include
struct st_type
{
int i;
int a[0];
};
int main()
{
printf("%d\n", sizeof(struct st_type));//4
return 0;
} （3）包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
3.柔性数组的使用：
#include
#include
#include
#include
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
#include
#include
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）这样有利于访问速度：连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）