1.几个经典的笔试题

题目1：

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

请问运行Test 函数会有什么样的结果？

答：没有打印结果

题目解释： 先调用Test函数，Test函数把str指针里边放成了空指针，再调用GetMemory函数，把str变量本身传给p，p为str的一份临时拷贝，p里边也是空指针。

malloc向内存申请了100个字节的空间，并把空间的地址传给了p

假设地址为0x0012ff40，那么p里边存放的也是0x0012ff40，所以p就指向了那100个空间

p为函数的形参变量，出了函数就会销毁，所以当p走出GetMemory函数，p里边的数据就不见了，p就销毁了

所以再Test函数里str依然是一个空指针，strcpy函数把hello world拷贝放在str这个空指针里必然会出现访问内存出错

总结：

这个代码的两个错误

1.调用GetMemory国数的时候，str的传参为值传递，p是str的临时拷贝，所以在GetMemory函数内部讲动态开辟空间的地址存放在p中的时候，不会影响str.所以GetMemory函数返回之后，str中依然是 NULL指针。strcpy函数就会调用失败，原因是对NULL的解引用操作，程序会崩溃。

2.GetMemory函数内容malloc申请的空间没有机会释放，造成了内存泄露。

如何修改呢？

把Test函数内部的p的值返回一下，并在GetMemory函数内部对其接收，拷贝完之后再对其打印一下，结果就出来了

修改后代码：

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

打印结果：

另一种修改方法：传str地址

char* GetMemory(char** p)
{
  *p = (char*)malloc(100);
  return p;
}
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(void)
{
  char p[] = "hello world";
  return p;
}
void Test(void)
{
  char* str = NULL;
  str = GetMemory();
  printf(str);
}
int main()
{
  Test();
  return 0;
}

请问运行Test 函数会有什么样的结果？

题目分析：先调用Test函数，Test函数把str指针里边放成了空指针，再调用GetMemory函数，GetMemory中创建了一个p数组，数组中放了hello world

return返回了p的地址，返回后str里放的就是p的地址

p的空间属于GetMemory函数，出了这个函数p的空间就会被回收

总结：

这个代码的错误：

返回栈空间地址的问题

GetMemory函数内部创建的数组是临时的，虽然返回了数组的起始地址给了str，但是数组的内存出了GetMemory函数就被回收了，而str依然保存了数组的起始地址，这时如果使用str, str就是野指针。

题目3：

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

运行Test函数会有什么结果

仔细观察这个代码与我们的题目一有点相似，但是这个代码没有free，因为没有free所以造成了内存泄漏，所以我们给他加上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);
  //释放
  free(str);
}
int main()
{
  Test();
  return 0;
}

运行结果：

题目4：

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函数会有什么结果？

这个代码确实打印出了结果，但是它还是有问题的，在这段代码中，执行到free(str)的时候，str指向的空间已经被回收了，所以后面的if语句中的strcpy函数，一旦执行就是非法访问

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

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

1.栈区 (stack)：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结東时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

2.堆区 (heap)：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。分配方式类似于链表。

3.数据段（静态区） (static) 存放全局变量、静态数据。程序结束后由系统释放。

4.代码段：存放函数体（类成员函数和全局丽数）的二进制代码。

有了这幅图，我们就可以更好的理解在《C语言初识》中讲的static关键字修饰局部变量的例子了。

实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。但是被static修饰的变量存放在数据段

（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁所以生命周期变长。

3. 柔性数组

也许你从来没有听说过柔性数组 (flexible array) 这个概念，但是它确实是存在的。 C99

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

例如：

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

有些编译器中会报错，改成

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

3.1 柔性数组的特点：

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

例如：

typedef struct st_type
{
  int i;
  int a[0];//柔性数组成员
}type_a;
int main()
{
  printf("%d\n", sizeof(type_a));//输出的是4
  return 0;
}

3.2 柔性数组的使用

//代码1
struct S
{
  int n;
  char c;
  int arr[0];//柔性数组成员
};
int main()
{
  //      8               + 40
  struct S* ps = (struct S*)malloc(sizeof(struct S) + 10*sizeof(int));
  if (ps == NULL)
  {
    printf("%s\n", strerror(errno));
    return 1;
  }
  //使用
  ps->n = 100;
  ps->c = 'w';
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    ps->arr[i] = i;
  }
  for (i = 0; i < 10; i++)
  {
    printf("%d\n", ps->arr[i]);
  }
  //调整arr数组的大小
  struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
  if (ptr == NULL)
  {
    printf("%s\n", strerror(errno));
    return 1;
  }
  else
  {
    ps = ptr;
  }
  //使用
  //...
  //释放
  free(ps);
  ps = NULL;
  return 0;
}

柔性数组arr相当于获得了10个空间，修改后获得了2个空间

3.3 柔性数组的优势

上述的结构体也可以设计为：

//代码2
struct S
{
  int n;
  char c;
  int* arr;
};
int main()
{
  struct S* ps = (struct S*)malloc(sizeof(struct S));
  if (ps == NULL)
  {
    perror("malloc");
    return 1;
  }
  int*ptr = (int*)malloc(10 * sizeof(int));
  if (ptr == NULL)
  {
    perror("malloc2");
    return 1;
  }
  else
  {
    ps->arr = ptr;
  }
  //使用
  ps->n = 100;
  ps->c = 'w';
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    ps->arr[i] = i;
  }
  //打印
  for (i = 0; i < 10; i++)
  {
    printf("%d ", ps->arr[i]);
  }
  //扩容 - 调整arr的大小
  ptr = realloc(ps->arr, 20 * sizeof(int));
  if (ptr == NULL)
  {
    perror("realloc");
    return 1;
  }
  else
  {
    ps->arr = ptr;
  }
  //使用
  //释放
  free(ps->arr);
  ps->arr = NULL;
  free(ps);
  ps = NULL;
  return 0;
}

上述代码1和代码2可以完成同样的功能，代码1是柔性数组方案，代码2是结构体中指针方案

两种方法对比：

代码1：malloc一次free一次，容易维护空间，不易出错

（ malloc次数少，内存碎片就较少，内存的使用率就较高一些）

代码2：malloc两次free两次，维护难度加大，容易出错

（malloc次数多，内存碎片就增多，内存的使用率就下降）

柔性数组的好处

第一个好处是：方便内存释放

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

第二个好处是：这样有利于访问速度.

连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得速度的差异比较小）

好了关于C语言【进阶】，七七今天就分享到这里了，如果这篇文章对大家有帮助，请佬佬们点个赞再走吧！如果发现什么问题，欢迎评论区留言！💕💕

动态内存管理——C语言【进阶】（下）