动态内存开辟

动态内存开辟

1. 为什么存在动态内存分配

   我们已经掌握的内存开辟方式有

   int val = 20; //在栈空间上开辟四个字节
   char arr[10] = {0}; //在栈空间上开辟10个字节的连续空间
   

   但是上述的空间开辟的方式有两个特点：

   • 空间开辟大小是固定的
   • 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配
     但是对于空间的需求不仅仅是上述的情况，很多时候我们到底需要多少空间，是随着程序的运行逐渐变化的，因此静态的空间开辟就不能满足需要了，需要进行动态内存开辟

2. 动态内存分配函数

   1. malloc()和free()

      #include <stdlib.h>
      void* malloc (size_t size);
      void free (void* ptr);
      

      malloc()向内存申请一块连续可用的匿名空间，并返回指向这块空间的指针

      • 若开辟成功，返回开辟成功空间的地址

      • 若开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。否则如果开辟失败而不知道，会产生对野指针解引用等问题

      • 返回值的类型是void*，所以mallloc()并不知道开辟空间的类型，具体在使用的时候使用者自己进行强制转换

        int* ptr = (int*) malloc(40); //开辟40个字节的int型空间
        int* p = ptr; //free()要从开辟空间的起始地址开始，所以不能直接用ptr
        if (p == NULL)) //检查动态内存空间开辟是否成功
        {
           perror("malloc");
           return 1;
        }
        
        int i = 0;
        for(i=0; i<10; i++)
        {
           *p = i;
           p++;
        }
        
        free(ptr); //释放空间
        ptr = NULL; //ptr释放后变成野指针，置空
        

      • 若参数size未定，则malloc()的行为是标准未定义的，由编译器决定

      free()用来释放回收动态开辟的内存

      • 若参数ptr指向的空间不是动态开辟的，则free()的行为未定义
      • 若参数ptr是NULL，则函数什么事都不做

   2. calloc

      void* calloc (size_t num, size_t size);
      

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

   3. realloc

      realloc()让动态内存开辟更加灵活。有时我们发现过去申请的空间太小了，有时我们又觉得太大了，那为了合理的使用内存，我们一定会对内存的大小进行灵活的调整。realloc()就可以做到对动态开辟内存大小的调整

      void* realloc (void* ptr, size_t size);
      

      • ptr为要调整的内存地址
      • size为调整之后新的内存空间的大小
      • 若开辟成功，则返回新空间的地址，否则返回NULL
      • 扩容时有两种情况
        • 原有空间之后有足够大的空间：直接扩展内存，原空间数据存放的数据不变
        • 原有空间之后的空间已经被用掉了，没有足够大的空间用来扩容
          • 在堆空间上找一个新的可用连续匿名空间，返回其地址
          • 拷贝原空间的数据到扩容的地址上
          • free原空间

      int* p = (int*)malloc(40);
      
      if (p == NULL)
      {
         perror("malloc");
         return 1;
      }
      
      int* ptr = (int*)realloc(p, 80); //将空间扩容为存储80字节的int数据的空间
      if (ptr != NULL)
      {
         p = ptr;
      }
      
      free(p);
      p = NULL;
      

3. 常见的动态内存错误

   1. 对NULL指针的解引用操作

      void test()
      {
         int* p = (int*)malloc(INT_MAX); //需要开辟的内存过大，malloc开辟失败，返回NULL
         *p = 20;
         free(p);
      }
      

      解决办法：对malloc函数的返回值进行判断后再使用

   2. 对动态内存开辟空间的越界访问

      void test()
      {
         int i = 0;
         int* p = (int*)malloc(10 * sizeof(int));
         if (p == NULL)
         {
            exit(EXIT_FAILURE);
         }
         
         for (i=0; i<=10; i++) //i<=10 访问11个int，造成越界
         {
            *(p+i) = i;
         }
      
         free(p);
      }
      

   3. 对非动态开辟内存使用free()

      int a = 10;
      int* p = &a;
      free(p);
      

   4. 使用free()释放一块动态内存的一部分

      int* p = (int*)malloc(40);
      p++;
      free(p);
      

   5. 对同一块动态内存多次释放

      int* p = (int*)malloc(40);
      free(p);
      free(p);
      

   6. 动态开辟内存忘记释放，造成内存泄漏 Memory leak

      void test()
      {
         int* p = (int*)mallloc(40);
         if (p != NULL)
         {
            *p = 20;
         }
      }
      
      int main()
      {
         test();
         while(1);
         return 1; //没有free()
      }