四、经典笔试题练习

执行下面的Test函数，分析会输出上面结果以及代码中存在什么问题。

1、笔试题1

void GetMemory(char* p)
{
  p = (char*)malloc(100);
}
void Test(void)
{
  char* str = NULL;
  GetMemory(str);  
  strcpy(str, "hello world");
  printf(str);  //将str的首地址传给printf函数，可行
}

分析：

上面这段程序有三个问题：

第一：在Test函数中调用GetMemory函数时，传递的是str的值，所以GetMemory函数的参数p只是str的一份临时拷贝，与str没有任何关系，将动态开辟的100个字节交由指针p管理并不会对str产生任何影响；而且就算传递的是str的地址，malloc函数申请空间也有可能失败；

第二：由于GetMemory函数并没有能让str获得空间，所以str仍为NULL，这时调用strcpy函数会导致程序错误；

第三：代码中并没有对动态开辟的100个字节空间进行free，会导致内存泄漏；

2、笔试题2

char* GetMemory(void)
{
  char p[] = "hello world";
  return p;
}
void Test(void)
{
  char* str = NULL;
  str = GetMemory();
  printf(str);
}

分析：

上面的程序有两个问题：

第一：在GetMemory函数中，p是一个数组，是在栈区上开辟空间，而不是在堆区上动态开辟的，所以当GetMemory函数被调用完毕后其函数栈帧会立即销毁，所以GetMemory函数并不能使str指向一块可用内存；

第二：GetMemory返回了p的地址，并将其赋值给了str，由于GetMemory函数调用完毕后其函数栈帧销毁，所以原本属于p的那块空间现在已经不能使用了，而str保存了p那块空间的起始地址并在printf函数中进行了访问，就造成了野指针问题；

3、笔试题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);
}

分析：

上面程序有两个问题：

第一：虽然这里把str的地址传递给了GetMemory函数，让其指向了一块动态开辟的空间，但是这里没有对malloc函数的返回值进行检查，当malloc失败的时候还是会产生空指针问题；

第二：程序中没有对malloc的空间进行free，造成了内存泄漏；

4、笔试题4

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

分析：

什么程序存在两个问题：

第一：没有对malloc的返回值进行空指针检查，使得strcpy函数可能执行失败；

第二：在free掉动态开辟的内存之后没有把相应的指针变量置空，导致if条件成立，造成野指针问题；

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

前面我们一直说C语言的内存空间一共分为栈区、堆区、静态区这三个区域，其实这只是简略的说法，内存空间的具体划分如下：（注意：这里我们只需要了解即可，关于内存空间划分的知识我们会在操作系统模块进行深入学习）

六、柔性数组

1、什么是柔性数组

在C99标准中，结构体中的最后一个元素允许是未知大小的数组，这就是柔性数组；柔性数组的特点如下：

柔性数组只能在结构体中使用；

结构体中的柔性数组成员前面必须至少有一个其他成员；

sizeof 计算含柔性数组成员的结构体大小时，不会包含柔性数组的大小；

包含柔性数组成员的结构体需要用 malloc 函数进行动态内存分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小；

当我们用为柔性数组成员开辟的空间大小不合适时，我们还可以使用 realloc 函数对其进行扩容，真正的做到 “柔性”；

例如：

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

2、柔性数组成员的定义

柔性数组成员的定义方式有两种：一种是把数组大小定义为0，这种定义方式在某些编译器下会报错；

struct S
{
  int n;
  int arr[0];  //柔性数组成员，把数组大小指定为0
};

另一种方式是直接不指定柔性数组的大小，这种方式比较通用，在支持C99标准的编译器下都不会报错；

struct S
{
  int n;
  int arr[];  //柔性数组成员，直接不指定数组大小
};

3、柔性数组的使用

我们在上面柔性数组的特点里面已经提到，包含柔性数组成员的结构体需要在堆区上开辟空间，其实这里开辟出来的空间会被分为两部分：一部分分配给结构体中普通成员变量使用，剩余的部分全部分配给柔性数组成员变量使用；

struct S
{
  int n;
  int arr[];  //柔性数组成员
};
int main()
{
  //开辟
  //malloc 中加号前面的部分为结构体普通成员开辟空间，加号后面部分为柔性数组成员开辟空间
  struct S* s = (struct S*)malloc(sizeof(struct S) + 40);
  if (s == NULL)
  {
    perror("malloc");  //perror函数，找到错误信息并打印
    return 1;
  }
  //扩容
  struct S* ptr = (struct S*)realloc(s, sizeof(struct S) + 80);
  if (ptr == NULL)
  {
    perror("malloc");  //perror函数，找到错误信息并打印
    return 1;
  }
  s = ptr;
  //使用
  s->n = 0;
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    s->arr[i] = i;
    printf("%d ", s->arr[i]);
  }
  //销毁
  free(s);
  s = NULL;
  return 0;
}

4、柔性数组的优势

如果动态内存管理基础学的扎实的同学可能会发现，我们完全可以在结构体中定义一个int*类型的成员变量，然后为此变量开辟一块空间，也可以达到柔性数组的效果，即如下面代码所示：

struct S
{
  int n;
  int* arr;  //指针变量
};
int main()
{
  //开辟:由于含柔性数组的结构体的空间完全是在堆区上开辟的，所以为了最大程度上模拟其效果，这里我们也在堆区上开辟空间
  //为结构体开辟空间
  struct S* s = (struct S*)malloc(sizeof(struct S));
  if (s == NULL)
  {
    perror("malloc");  //perror函数，找到错误信息并打印
    return 1;
  }
  //让结构体中的int*变量指向另一块开辟的空间
  s->arr = (int*)malloc(20);
  if (s->arr == NULL)
  {
    perror("malloc");
    return 1;
  }
  //扩容为int*指向的空间
  int* ptr = (int*)realloc(s->arr, 40);
  if (ptr == NULL)
  {
    perror("realloc");
    return 1;
  }
  s->arr = ptr;
  //使用
  s->n = 0;
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    s->arr[i] = i;
    printf("%d ", s->arr[i]);
  }
  //销毁：这里注意要开辟的两块空间全部销毁掉
  free(s->arr);
  free(s);
  s = NULL;
  return 0;
}

我们可以看到，上面的方法也可以实现柔性数组的效果，那为什么还要存在柔性数组呢？其实是因为柔性数组有着如下优势：

方便内存释放。对于第二种代码，如果我们的代码是在一个给别人用的函数中，我们在里面做了二次内存分配，并把整个结构体返回给用户；用户调用 free 函数可以释放结构体，但是用户并不知道这个结构体内的成员也需要 free，我们不能指望用户来发现这个事；所以，如果我们像第一种代码那样，把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次 free 就可以把所有的内存也给释放掉，很大程度上避免了内存泄露。

有利于提高访问速度。第二种方法我们用了两次 malloc 函数，这会一定程度上导致内存碎片；而第一种我们只使用了一次 malloc 函数，提高了内存的连续性；连续的内存有利于提高访问速度。

扩展阅读：C语言结构体里的成员数组和指针

【C语言】动态内存管理（2）