【C++】：内存管理

int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
  static int staticVar = 1;
  int localVar = 1;
  int num1[10] = { 1, 2, 3, 4 };
  char char2[] = "abcd";
  const char* pChar3 = "abcd";
  int* ptr1 = (int*)malloc(sizeof(int) * 4);
  int* ptr2 = (int*)calloc(4, sizeof(int));
  int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
  free(ptr1);
  free(ptr3);
}

void Test()
{
  int* p1 = (int*)malloc(sizeof(int));
  free(p1);
  // 1.malloc/calloc/realloc的区别是什么？
  int* p2 = (int*)calloc(4, sizeof(int));
  int* p3 = (int*)realloc(p2, sizeof(int) * 10);
  // 这里需要free(p2)吗？
  free(p3);
}

void Test()
{
  //动态申请一个int类型的空间
  int* ptr1 = new int;
  //动态申请10个int类型的空间
  int* ptr2 = new int[10];
  //动态申请一个int类型空间，并且初始化为0
  int* ptr3 = new int(0);
  //释放
  delete ptr1;
  delete[] ptr2;
  delete ptr3;
}

class A
{
public:
  A(int a = 0)
    : _a(a)
  {
    cout << "A():" << this << endl;
  }
  ~A()
  {
    cout << "~A():" << this << endl;
  }
private:
  int _a;
};
int main()
{
  //malloc
  A* p1 = (A*)malloc(sizeof(A));
  if (p1 == nullptr)
  {
    perror("malloc fail");
    exit(-1);
  }
  //new
  A* p2 = new A(1);
  A* p3 = (A*)malloc(sizeof(A) * 5);
  if (p3 == nullptr)
  {
    perror("malloc fail");
    exit(-1);
  }
  A* p4 = new A[10];
  free(p1);
  delete p2;
  free(p3);
  delete[] p4;
  return 0;
}

/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间
失败，尝试执行空间不足应对措施，如果该应对措施用户设置了，则继续申请，否则抛异常。
*/
void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
  // try to allocate size bytes
  void* p;
  while ((p = malloc(size)) == 0)
    if (_callnewh(size) == 0)
    {
      // report no memory
      // 如果申请内存失败了，这里会抛出bad_alloc 类型异常
      static const std::bad_alloc nomem;
      _RAISE(nomem);
    }
  return (p);
}
/*
operator delete: 该函数最终是通过free来释放空间的
*/
void operator delete(void* pUserData)
{
  _CrtMemBlockHeader* pHead;
  RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
  if (pUserData == NULL)
    return;
  _mlock(_HEAP_LOCK); /* block other threads */
  __TRY
    /* get a pointer to memory block header */
    pHead = pHdr(pUserData);
  /* verify block type */
  _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
  _free_dbg(pUserData, pHead->nBlockUse);
  __FINALLY
    _munlock(_HEAP_LOCK); /* release other threads */
  __END_TRY_FINALLY
    return;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)

int main()
{
  //直接开辟是会崩溃
  //char* ptr = new char[0x7fffffff];
  //抛异常处理
  try
  {
    char* ptr = new char[0x7fffffff];
    //抛异常之后下面的程序不会执行，直接跳转至catch
    cout << (void*)ptr << endl;
  }
  catch (const exception& e)
  {
    cout << e.what() << endl;
  }
  return 0;
}

void func()
{
  char* ptr = new char[0x7fffffff];
  //抛异常之后下面的程序不会执行，直接跳转至catch
  cout << (void*)ptr << endl;
}
int main()
{
  //直接开辟是会崩溃
  //char* ptr = new char[0x7fffffff];
  //抛异常处理
  try
  {
    func();
  }
  catch (const exception& e)
  {
    cout << e.what() << endl;
  }
  return 0;
}

class A
{
public:
  A(int a = 0)
    : _a(a)
  {
    cout << "A():" << this << endl;
  }
  ~A()
  {
    cout << "~A():" << this << endl;
  }
private:
  int _a;
};
// 定位new/replacement new
int main()
{
  // p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没
  //有执行
  A* p1 = (A*)malloc(sizeof(A));
  //显示的调用构造函数
  //p1->A(1);  //这样子写是不支持的
  new(p1)A(1); // 注意：如果A类的构造函数有参数时，此处需要传参
  p1->~A();
  free(p1);
  A* p2 = (A*)operator new(sizeof(A));
  new(p2)A(10);
  p2->~A();
  operator delete(p2);
  return 0;
}

void Func()
{
  try
  {
    char* ptr = new char[0x7fffffff];
  }
  catch (const exception& e)
  {
    cout << e.what() << endl;
  }
}
void MemoryLeaks()
{
  // 1.内存申请了忘记释放
  int* p1 = (int*)malloc(sizeof(int));
  int* p2 = new int;
  // 2.异常安全问题
  int* p3 = new int[10];
  Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
  delete[] p3;
}

int main()
{
    int* p = new int[10];
    // 将该函数放在main函数之后，每次程序退出的时候就会检测是否存在内存泄漏
    _CrtDumpMemoryLeaks();
    return 0;
}
// 程序退出后，在输出窗口中可以检测到泄漏了多少字节，但是没有具体的位置
Detected memory leaks!
Dumping objects ->
{79} normal block at 0x00EC5FB8, 40 bytes long.
Data: < > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
Object dump complete.