【动态内存管理】-阿里云开发者社区

1. 动态内存函数

（1）malloc和free

这个函数向内存（堆区）申请一块连续可用的空间，并返回指向这块空间的指针.
如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

malloc向内存申请一块连续可用的空间，当然，申请完后要归还给操作系统，这时候就要使用free函数归还了；

free函数用来释放动态开辟的内存。
如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
如果参数 ptr 是NULL指针，则函数什么事都不做。

eg:

int main()
      {
        //开辟一个大小为4*整型个字节的空间大小
        int* p = (int*)malloc(4 * sizeof(int));
        //如果开辟空间失败，p为空指针，断言判断p是否为空，为空则报错
        assert(p);
        int i = 0;
        //赋值并打印
        for (i = 0; i < 4; i++)
        {
          //两种都可以
          //*(p + i) = i;
          //printf("%d ", *(p + i));
          p[i] = i;
          printf("%d ", p[i]);
        }
        //归还空间
        free(p);
        //并把p置空，如果不置空，p将成为野指针
        p = NULL;
        return 0;
      }

（2）calloc

函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

eg:

int main()
      {
        //向空间申请sizeof(int)*10个空间，并初始化为0
        int* p = (int*)calloc(10, sizeof(int));
        assert(p);
        int i = 0;
        for (i = 0; i < 10; i++)
        {
          printf("%d ", *(p + i));
        }
        free(p);
        p = NULL;
        return 0;
      }

（3）realloc

ptr 是要调整的内存地址
size 调整之后新大小
返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
realloc在调整内存空间的是存在两种情况

(1) 情况1：原有空间之后有足够大的空间

当是情况1的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化；而且realloc返回的是旧地址p；

（2）情况2：原有空间之后没有足够大的空间

当是情况2的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址ptr.

eg：

int main()
      {
        //先开辟一块大小为10*sizeof(int)的空间
        int* p = (int*)malloc(10 * sizeof(int));
        assert(p);
        int i = 0;
        for (i = 0; i < 10; i++)
        {
          *(p + i) = i + 1;
          printf("%d ", *(p + i));
        }
        //拓展p的空间，拓展后的大小为20 * sizeof(int)
        int* ptr = (int*)realloc(p, 20 * sizeof(int));
        assert(ptr);
        p = ptr;
        for (i = 10; i < 20; i++)
        {
          *(p + i) = i + 1;
          printf("%d ", *(p + i));
        }
        free(p);
        p = NULL;
        return 0;
      }

二、笔试题

笔试题1

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

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

（2）GetMemory函数内向malloc申请的空间没有机会释放，造成内存泄漏。

改造1：

//返回一个指针
      char* GetMemory()
      {
        char* p = (char*)malloc(100);
        return p;
      }
      void Test(void)
      {
        char* str = NULL;
        //用指针接收
        str = GetMemory();
        strcpy(str, "hello world");
        printf(str);
        free(str);
        str = NULL;
      }
      int main()
      {
        Test();
        return 0;
      }

改造2：

//用二级指针接收
      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

返回栈空间地址问题：

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

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

三、柔性数组

1.柔性数组的定义

结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员，例如：

typedef struct st_type
      {
       int i;
       int a[0];//柔性数组成员
      }type_a;

也可以写成：

typedef struct st_type
      {
       int i;
       int a[];//柔性数组成员
      }type_a;

2. 柔性数组的特点

（1）结构中的柔性数组成员前面必须至少一个其他成员。

（2）sizeof 返回的这种结构大小不包括柔性数组的内存。

（3）包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

3. 柔性数组的使用

在这里举两个例子，一个是使用柔性数组，第二个是使用结构体中指针方案，两个效果一样，但是也有所差异，我们可以对比一下；

柔性数组的方案（方案1）：

struct S
      {
        int a;
        char ch;
        int arr[];   //柔性数组成员
      };
      int main()
      {
        //为柔性数组开辟空间
        //                 8                           +         40    = 48
        struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
        assert(ps);
        int i = 0;
        for (i = 0; i < 10; i++)
        {
          ps->arr[i] = i + 1;
          printf("%d ", ps->arr[i]);
        }
        printf("\n");
        ps->a = 10;
        ps->ch = 'w';
        printf("%d\n%c\n", ps->a, ps->ch);
        free(ps);
        ps = NULL;
        return 0;
      }

结构体中指针方案（方案2）：

struct S
      {
        int a;
        char ch;
        int* arr;
      };
      int main()
      {
        //为结构体开辟空间
        struct S* ps = (struct S*)malloc(sizeof(struct S));
        assert(ps);
        //为结构体中的数组指针开辟空间
        struct S* ptr = (int*)malloc(10 * sizeof(int));
        assert(ptr);
        ps->arr = ptr;
        int i = 0;
        for (i = 0; i < 10; i++)
        {
          ps->arr[i] = i + 1;
          printf("%d ", ps->arr[i]);
        }
        free(ptr);
        free(ps);
        ptr = NULL;
        ps = NULL;
        return 0;
      }

以上两种方案的效果都一样，但是方案1，malloc一次，free一次，容易维护空间，不易出错；而且malloc次数少，内存碎片就会较少，内存的使用率就会较高一些；

方案2，malloc两次，free两次，维护难度加大，容易出错；而且malloc次数多，内存碎片就会增加，内存的使用率就下降了；

【动态内存管理】