动态内存申请的结果

• 问题

  动态内存申请一定成功么？

• 常见的动态内存分配代码 C代码:

  int *p = (int*)malloc(10*sizeof(int));
  if(p != NULL){
      //... ...
  }

  C++代码:

  int *p = new int[10];
  if(p != NULL){
      //... ...
  }

• 必须知道的事实

  • malloc函数申请失败时返回NULL值
  • new关键字申请失败时(根据编译器的不同)
    • 返回nullptr值
    • 抛出std::bad_alloc异常

• 问题

  new语句中的异常是怎么抛出来的？

• new关键字在C++规范中的标准行为

  • 在堆空间申请足够大的内存
    • 成功
      • 在获取的空间中调用构造函数创建对象
    • 返回对象的地址
    • 失败
      • 抛出std::bad_alloc异常
  • new在分配内存时
    • 如果空间不足，会调用全局的new_handler()函数
    • new_handler()函数中抛出std::bad_alloc异常
  • 可以自定义new_handler()函数
    • 处理默认的new内存分配失败的情况

• new_handler()的定义和使用

  void my_new_handler() {
      cout<<"No enough memory";
      cout<<endl;
      exit(1);
  }
  
  int main(int argc,char *argv[ ]) {
      set_new_handler(my_new_handler);
      //... ...
      return 0;
  }

• 问题

  如何跨编译器统一new的行为，提高代码移植性？

• 解决方案

  • 全局范围(不推荐)
    • 重新定义new/delete的实现，不抛出任何异常
    • 自定义new_handler函数，不抛出任何异常
  • 类层次范围
    • 重载new/delete，不抛出任何异常
  • 单次动态内存分配
    • 使用nothrow参数，指明new不抛出异常

编程实验

• 动态内存申请

  #include <iostream>
  #include <new>
  #include <cstdlib>
  #include <exception>
  
  using namespace std;
  
  class Test {
      int m_value;
  public:
      Test() {
          cout << "Test()" << endl;
          m_value = 0;
      }
      
      ~Test() {
          cout << "~Test()" << endl;  
      }
      
      void* operator new (unsigned int size) throw() {
          cout << "operator new: " << size << endl;
          
          // return malloc(size);
          return NULL;
      }
      
      void operator delete (void* p) {
          cout << "operator delete: " << p << endl;
          
          free(p);
      }
      
      void* operator new[] (unsigned int size) throw() {
          cout << "operator new[]: " << size << endl;
          
          // return malloc(size);
          return NULL;
      }
      
      void operator delete[] (void* p) {
          cout << "operator delete[]: " << p << endl;
          
          free(p);
      }
  };
  
  void my_new_handler() {
      cout << "void my_new_handler()" << endl;
  }
  
  void ex_func_1() {
      new_handler func = set_new_handler(my_new_handler);
      
      try {
          cout << "func = " << func << endl;
          
          if( func ) func();  
      } catch(const bad_alloc&) {
          cout << "catch(const bad_alloc&)" << endl;
      }
  }
  
  void ex_func_2() {
      Test* pt = new Test();
      
      cout << "pt = " << pt << endl;
      
      delete pt;
      
      pt = new Test[5];
      
      cout << "pt = " << pt << endl;
      
      delete[] pt; 
  }
  
  void ex_func_3() {
      int* p = new(nothrow) int[10];
      
      // ... ...
      
      delete[] p; 
      
      int bb[2] = {0};
      
      struct ST {
          int x;
          int y;
      };
      
      ST* pt = new(bb) ST();
      
      pt->x = 1;
      pt->y = 2;
      
      cout << bb[0] << endl;
      cout << bb[1] << endl;
      
      pt->~ST();
  }
  
  int main(int argc, char *argv[]) {
      // ex_func_1();
      // ex_func_2();
      // ex_func_3();
      
      return 0;
  }
  
  

• 实验结论

  • 不是所有的编译器都遵循C++的标准规范
  • 编译器可能重定义new的实现，并在实现中抛出bad_alloc异常
  • 编译器的默认实现中，可能没有设置全局的new_handler函数
  • 对于移植性要求较高的代码，需要考虑new的具体细节

小结

• 不同的编译器在动态内存分配上的实现细节不同
• malloc函数在内存申请失败时返回nullptr值
• new关键字在内存申请失败时
  • 可能返回nullptr值
  • 可能抛出bad_alloc异常上