C语言——动态内存管理经典笔试题+柔性数组
Posted Recipe.
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C语言——动态内存管理经典笔试题+柔性数组相关的知识，希望对你有一定的参考价值。
前言
(一)C/C++程序的内存开辟
(二)柔性数组
(三)动态内存管理——经典笔试题
1.C/C++程序的内存开辟
(一)C/C++程序内存分配的几个区域：
1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结
束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是
分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返
回地址等。
2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分
配方式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。
有了这幅图，我们就可以更好的理解在《C语言初识》中讲的static关键字修饰局部变量的例子了。
实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序
结束才销毁
所以生命周期变长。
补充一点上一个博客里动态内存管理realloc的用法
realloc是调整申请的堆区内存的大小的，其实也可以像malloc一样申请开辟空间。
我们把第一个指针给为空指针。
(二)柔性数组
也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。
C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。
例如：
或者
在前面我们学过结构体的大小是内存对齐，联合的大小是共用一块空间，先求出各自的内存对齐大小，再减去联合体最大成员的数据类型即可，那么我们看看柔性数组的大小。
结果是8，是因为sizeof返回的这种结构大小不包括柔性数组的内存。
柔性数组的特点：
结构中的柔性数组成员前面必须至少一个其他成员。
sizeof 返回的这种结构大小不包括柔性数组的内存。
包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大
小，以适应柔性数组的预期大小。
那么柔性数组怎么使用呢?
相当于sizeof(struct S)是给int n和char f申请堆区中内存的空间， 而10*sizeof(int)是给int arr[0]申请了40个字节的空间，相当于进化成了arr[10];
我们也可以用realloc来重新调整柔性数组成员的大小
我们再写另一种柔性数组的写法
这次用指针来表示柔性数组成员；
因为两次malloc在堆区申请的空间不一定是连续的，中间可能会别的数据内存占据，内存碎片化就会增多。
第一个写法的好处是：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给
用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你
不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好
了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
第二个好处是：这样有利于访问速度.
连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正
你跑不了要用做偏移量的加法来寻址。
(三)动态内存管理——经典笔试题
题目1
怎么修改才正确呢？
题目2
‘
这是一个经典返回栈空间地址的问题
什么意思？我们写一段代码试一试
为什么会这样呢？因为栈帧空间被覆盖了。
题目3：
这次的题目问题不大，只是没有free释放空间，造成内存泄漏。加个free(str),str=NULL;即可。
题目4：
没有把str置为空指针，下面的strcpy里面的str相当于非法访问=野指针。
动态内存管理（动态内存函数的介绍，c/c++经典笔试题，柔性数组）
🎉🎇🎆👀😄❤️👍💪
🎓为什么存在动态内存分配
常见的创建变量，开辟空间，分配内存的方式如下：
int val = 20;//在栈空间上开辟四个字节
char arr[10] = 0;//在栈空间上开辟10个字节的连续空间
✏️上面的方式称为静态开辟，它有如下几个特点：
- 空间开辟大小是固定的。
- 数组在声明的时候，必须指定数组的长度，它所需要的内存在编译时分配。但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了，
这时候就只能试试动态内存开辟了。
如通过下面的简单例子，你就明白，下面是一个简略的未完善的代码：
假设我创建一个学生结构体数组，结构体成员包括姓名，性别，年龄，假设我首先静态的给数组开辟100个元素空间，之后向里面又添加元素，但慢慢的里面的元素个数会超过我们定义的最大元素个数，可能之后造成数组越界，不够用等情况，所以这种情况我们可以动态的开辟数组空间，够了就用，不够继系开辟即可。
#include<stdio.h>
#define MAX 1000//初始大小,100个学生
#define ADD 5//增加5个学生
struct student
char name[20];
char sex[4];
int age;
student;
//静态版本
//struct student data[MAX];
//动态版本
struct student *data;
void add(struct student* pc)
data = (struct student*)malloc((MAX+ADD) * sizeof(struct student));
if (data == NULL)
perror("InitContact");
return;
//.............................
//.............................
int main()
add(data);
return 0;
🎓动态内存函数的介绍
✏️malloc和free
这两个函数总是成对出现的，一个开辟内存，一个释放内存，这两个函数的单独使用极有可能会导致程序出错。
动态内存开辟的函数malloc
函数原型 void* malloc (size_t size);
函数说明
- 这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。 如果开辟成功，则返回一个指向开辟好空间的指针
- size_t size表示开辟几个字节大小的空间
- 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
- 如果参数 size为0，malloc的行为是标准是未定义的，取决于编译器。
动态内存释放函数free
函数原型 void free (void* ptr);
函数说明
- -ptr 传过来的是开辟空间的起始地址， 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的,如果为空指针什么也不会发生
- 如果参数 ptr 是NULL指针，则函数什么事都不做。 free函数释放内存空间后，并不会将接受开辟空间起始地址的的指针置为空指针
malloc和free都声明在 stdlib.h 头文件中，接下来我举一个开辟内存释放内存的例子：
#include <stdlib.h>
int main()
//动态内存开辟的
int* p = (int*)malloc(10*sizeof(int));//void*
//使用这些空间的时候首先判断空间是否开辟成功
if (p == NULL)
perror("main");//如果在main函数里面，开辟空间失败，通过perror函数打印错误信息
return 0;
//使用
int i = 0;
for (i = 0; i < 10; i++)
*(p + i) = i;//通过指针加减整数的方式赋初值
for (i = 0; i < 10; i++)
printf("%d ", *(p + i));//p[i] --> *(p+i)这两种访问方式等价的，p指向开辟的那块空间的起始地址，
//相当于数组名通过数组名加下标的方式访问访问开辟的空间
//回收空间
free(p);///free函数释放P指向的内存空间，但不会把p指针里面地址的内容释放，这可能就会造成，p又通过地址访问之前的内存空间，造成内存非法访问
p = NULL;//所以自己动手把p置为NULL
return 0;
💏💏这里有几个细节的地方学要注意：
malloc开辟空间后，free函数释放P指向的内存空间，但不会把p指针里面地址的内容释放，这可能就会造成，p又通过地址访问之前的内存空间，造成内存非法访问，所以一定要手动的把把P置为NULL
✏️calloc
C语言还提供了一个函数叫 calloc ， calloc 函数也用来动态内存分配。
函数原型如下： void* calloc (size_t num, size_t size); 函数说明：
- 函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
- 与函数 malloc 的区别只在于calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。
举个例子我们使用calloc开辟10个整形空间的大小
#include <stdlib.h>
int main()
//int*p = (int*)malloc(40);
int* p = calloc(10, sizeof(int));
if (p == NULL)
return 1;//如果为空直接结束后面的执行
int i = 0;
for (i = 0; i < 10; i++)
printf("%d\\n", *(p + i));
free(p);
p = NULL;
return 0;
打印calloc开辟空间里面的内容如图：
所以如果我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloc函数来完成任务。
✏️realloc
realloc函数的出现让动态内存管理更加灵活。有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理地管理内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。
函数原型如下： void* realloc (void* ptr, size_t size);
函数说明：
- 这个函数可以在原有的其它内存函数开辟空间的基础上，继系管理空间的大小，也可以自己重新开辟一块新的内存空间，开辟空间时不初始化里面的内容。
- ptr 是要调整的内存地址（原内存的起始地址）， size 为调整之后内存空间的新大小 返回值为调整之后的内存起始位置。
- 这个函数调整原内存空间时，如果原内存空间后面有足够的空间则开辟相应的空间，如果原内存空间后面没有足够的空间可以开辟，就在堆区重新找一块空间开辟内存，之后还会将原来内存中的数据移动到新 的空间。
realloc在调整内存空间的是存在两种情况：
情况1：原有空间之后有足够大的空间
情况2：原有空间之后没有足够大的空间
以下面的的代码为例，下图分析两种情况：
情况一：
情况二：
#include <stdlib.h>
int main()
int* p = (int*)calloc(3, sizeof(int));//开辟3个大小的整形空间
if (p == NULL)
perror("main");
return 1;
//如果这里需要p指向的空间更大，需要6个int的空间
//realloc调整空间
int*ptr = (int*)realloc(p, 6*sizeof(int));
if (ptr != NULL)
p = ptr;
//使用
int i = 0;
for (i = 0; i < 6; i++)
printf("%d ", *(p + i));
//回收空间
free(p);
p = NULL;
return 0;
✏️当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。当是情况2 的时候，如果原内存空间后面没有足够的空间可以开辟，就在堆区重新找一块空间开辟内存，之后还会将原来内存中的数据移动到新的空间。
🎓常见的动态内存错误
👀对NULL指针的解引用操作
空指针就是没有任何指向的指针，不能对它进行解引用，加减整数等操作，任何对它的操作都是不和法的，都会造成程序的崩溃。malloc函数在开辟内存失败时，会返回空指针，所以在对malloc函数开辟的空间进行使用之前要判断是否为返回空指针。
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
int* p = (int*)malloc(10000000000000000);
//开辟失败，返回空指针没有判断就使用
//使用
int i = 0;
for (i = 0; i < 6; i++)
printf("%d ", *(p + i));
👀对动态开辟空间的越界访问
其实这个很好理解，就像静态的创建10个数组元素，你可不能访问20个元素啊；如下面的代码，malloc动态的开辟了10整形大小的空间，下面使用空间时却访问了40个整形元素，这也是不合法的。
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
return 1;
int i = 0;
//越界访问
for (i = 0; i < 40; i++)
*(p + i) = i;
free(p);
p = NULL;
return 0;
🔧🔩对非动态开辟内存使用free释放
通过什么方式创建，就要通过什么方式释放
int main()
int arr[10] = 0 ;//栈区
int* p = arr;
//使用
free(p);//使用free释放非动态开辟的空间
p = NULL;
return 0;
✏️使用free释放一块动态开辟内存的一部分free（p），p一定要指向开辟空间的起始位置，这样才能释放开辟的整块动态空间，如果p因为使用原因进行了移动一定要定义另一个指针记录p的开始指向位置，否则进行的内存释放是局部的内存释放。下面代码中通过指针的移动对空间内容进行了赋值，p发生了移动，但没有记录p的起始位置。
int main()
int* p = malloc(10 * sizeof(int));
if (p == NULL)
return 1;
int i = 0;
for (i = 0; i < 5; i++)
*p++ = i;
free(p);
p = NULL;
return 0;
🎸🎧对同一块动态内存多次释放
对于开辟的一块动态空间，一次释放就行，但有时由于程序的复杂，在多个函数里面使用这块空间，也就可能会进行多次释放。
int main()
int* p = (int*)malloc(100);
//使用
//释放
free(p);
p = NULL;
test（）
//释放
free(p);
return 0;
👻🤡动态开辟内存忘记释放（内存泄漏）
如下p是局部变量,出了这个函数就销毁了，下面的main 函数里面就不能使用了，之后就找不到p原来指向的空间的内容了，下面就不能把这块空间释放掉,造成内存泄漏，时间一长会消耗很多内存，如果服务器里面有内存泄漏，导致这个服务器崩溃。
void test()
int* p = (int*)malloc(100);
if (p == NULL)//p是局部变量,出了这个函数就销毁了
return;
else
//使用
//一块空间开辟了自己用，用完了一定要记得释放,这里不释放，下面就不能把这块空间释放掉,造成内存泄漏
int main()
test();//函数调用
//....
return 0;
🎓几个经典的笔试题
📝题目一：
首先思考这个代码有哪些问题？？
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. 存在内存泄漏
图示解释📐✏️✂️
✏️代码修改的两种方法
✏️在函数调用时，传值调用是无法改变实参的大小的，要传地址。
//改1
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;
int main()
Test();
return 0;
//改:2
//char* GetMemory(char* p)//改变函数的返回值，返回动态开辟空间的起始地址（char*）
//
// p = (char*)malloc(100);
// return p;
//
//void Test(void)
//
// char* str = NULL;
// str = GetMemory(str);
// strcpy(str, "hello world");
// printf(str);//?
// //printf("hello world");//char *p = "hello world";
// free(str);
// str = NULL;
//
//int main()
//
// Test();
// return 0;
//
📝题目二：
❌静态开辟的空间是在栈上，栈上开辟的空间出了作用域就销毁了，动态开辟的空间是在堆上开辟的，要么自己手动释放空间，要么程序结束自动释放空间。所以下面的代码，随机打印内存中的一些值，没有达到预想到的效果。
//GetMemory 函数内部创建的数组是在栈区上创建的
//出了函数，p数组的空间就还给了操作系统
//返回的地址是没有实际的意义，如果通过返回的地址，去访问内存就是非法访问内存的
char* GetMemory(void)
char p[] = "hello world";
return p;
void Test(void)
char* str = NULL;
str = GetMemory();
printf(str);//没有返回确定的地址，随机打印内存中的一些值
📝题目三
❌返回&x是无效的，局部变量返回地址是无效的
int test (void)
int x = 10;
return (&x);
📝题目四
❌局部变量不初始化，随机赋值，导致指向不明确，解引用有问题，野指针问题。
int test(void)
int *x;
*x = 10;
return x;
📝题目五
❌开辟空间没有free释放掉
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;
📝题目六
❌动态空间开辟好后，free释放开辟的空间，那么维护开辟空间起始位置的指针也应该置为空指针，这是紧紧相连的步骤，不可缺少。虽然free(str)释放了开辟好的空间，但str里面任然存储着开辟空间的起始地址，free不会释放strl里面的内容的，导致非法访问，导致程序错误。
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++程序的内存开辟
💡C/C++程序内存分配的几个区域如下图：
不同的变量，程序在内存中占有不同的区域，理解他们所在的区域，理解他们的作用域与生命周期，可以帮助我们更好地编写程序。
- 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有
限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。 - 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似
于链表。 - 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
- 代码段：存放函数体（类成员函数和全局函数）的二进制代码。
编译产生的可执行代码（可执行程序）是放在代码段区域的，常量字符串
也是放在代码段里面的。
💡有了这幅图，我们就可以更好地理解static关键字修饰的局部变量了
实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁所以生命周期变长。
🎓 柔性数组
柔性数组（flexible array）这个概念我们很少听到，但是它确实是存在的。 C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做柔性数组成员。我自己对于柔性数组的理解就是，柔性数组是定义在结构体当中的一个成员，它的起始大小为零，在使用过程中，根据情况的需要，通过动态内存开辟函数改变它的大小，达到数组内容改变的效果。
如：
struct S
int n;
int arr[];//大小是未知
// int arr[0];//大小是未知,这种柔性数组的写法也对，大小未知，不是柔性数组，这个写法就是非法的
;
✏️柔性数组的特点：
- 结构体中的柔性数组成员前面必须至少一个其他成员。
- sizeof 返回的这种结构大小不包括柔性数组的内存。
- 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应 柔性数组的预期大小。
✏️ 如下代码进行结构体的大小的计算：
#include<stdio.h>
struct s
int i;
int a[];//柔性数组成员
a;
int main()
printf("%d\\n", sizeof(struct s ));//输出的是4
return 0;
下面为柔性数组的简单使用：
代码一
首先数组元素个数为10个,不够时再动态的开辟为20个
#include<stdio.h>
struct S
int n;//4
int arr[0];//大小是未知
;
int main()
//期望arr的大小是10个整形
struct S*ps = (struct S*)malloc(sizeof(struct S)+10*sizeof(int));
ps->n = 10;
int i = 0;
//使用柔性数组
动态内存管理（动态内存函数的介绍，c/c++经典笔试题，柔性数组）
动态内存管理（动态内存函数的介绍，c/c++经典笔试题，柔性数组）