1024程序员节特辑 | 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* ptr4 = new int;

  // 动态申请一个int类型的空间并初始化为10
  int* ptr5 = new int(10);

  // 动态申请10个int类型的空间
  int* ptr6 = new int[3];
  delete ptr4;
  delete ptr5;
  delete[] ptr6;
}

class A
{
public:
  A(int a = 0)
    : _a(a)
  {
    cout << "A():" << this << endl;
  }

  ~A()
  {
    cout << "~A():" << this << endl;
  }

private:
  int _a;
};

int main()
{
  //malloc没有办法很好的支持自定义类型动态申请空间的初始化-->new
  A* p1 = (A*)malloc(sizeof(A));
  //p1->A(1); 创建对象时，自动调用，不可显示调用

  //new = malloc + 构造函数 （申请空间+ 初始化）
  A* p2 = new A;
  A* p3 = new A(1);
  //delete = 析构函数 + free
  delete p2;
  delete p3;

  A* p4 = new A[10];
  delete[] p4;

  A a1(1);
  A a2(2);
  A* p5 = new A[10]{ a1,a2 };
  delete[] p5;

  //匿名对象
  A* p6 = new A[10]{ A(1), A(2) };
  delete[] p6;

  //隐式类型转换
  A* p7 = new A[10]{ 1,2 };
  delete[] p7;
  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)

void func()
{
  char* ptr = new char[0x7fffffff];
  cout << (void*)ptr << endl;
}

int main()
{
  try
  {
    //char* ptr = new char[0x7fffffff];
    //*cout << ptr << endl;*//对于char*， cout不会按指针打印，会按照字符串打印。
                //同时由于编码等问题，会报屯屯...
    //cout << (void*)ptr << endl;

    func();
    cout << "hello C++" << endl;
  }
  catch (const exception& e)
  {
    cout << e.what() << endl;
  }

  return 0;
}

class A
{
public:
  A(int a = 1)
    :_a(a)
  {
  
  }
  ~A()
  {
    cout<<"~A"<<endl;
  }

private:
  int _a;
};
int main()
{
  A* p2 = new A[10];
  delete p2;
  return 0;
}
int main()
{
  //Stack* ptr = (Stack*)operator new(sizeof(Stack));
  //operator delete(ptr);

  A* p2 = new A[10];
  //delete[] p2;
  //free(p2);
  delete p2;
  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));
   new(p1)A;  // 注意：如果A类的构造函数有参数时，此处需要传参
   p1->~A();
   free(p1);
   
   A* p2 = (A*)operator new(sizeof(A));
   new(p2)A(10);
   p2->~A();
   operator delete(p2);
   return 0;
}

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.