从C语言到C++⑨(第三章_C&C++内存管理)详解new和delete+面试题笔试题（中）

/*
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)

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
  char* p1 = (char*)malloc(1024u * 1024u * 1024u * 2u);
  if (p1 == nullptr) 
  {
    printf("%d\n", errno);
    perror("malloc fail");
    exit(-1);
  }
  else 
  {
    printf("%p\n", p1);
  }
 
  return 0;
}

#include <iostream>
using namespace std;
 
int main()
{
  char* p2 = nullptr;
  try
  {
    char* p2 = new char[1024u * 1024u * 1024u * 2u - 1];
  }
  catch (const exception& e) 
  {
    cout << e.what() << endl;
  }
  printf("%p\n", p2);
 
  return 0;
}

#include<iostream>
using namespace std;
 
class A
{
public:
  A(int a = 0)
    : _a(a)
  {
    cout << "A():" << this << endl;
  }
 
  ~A()
  {
    cout << "~A():" << this << endl;
  }
 
private:
  int _a;
};
 
// 重载operator delete，在申请空间时：打印在哪个文件、哪个函数、第多少行，申请了多少个字节
void* operator new(size_t size, const char* fileName, const char* funcName, size_t lineNo)
{
  void* p = ::operator new(size);
  cout << "new:" << fileName << "||" << funcName << "||" << lineNo << "||" << p << "||" << size << endl;
  return p;
}
 
 重载operator delete，在释放空间时：打印再那个文件、哪个函数、第多少行释放，不实现这个，不然使用要加（）
//void operator delete(void* p, const char* fileName, const char* funcName, size_t lineNo)
//{
//  cout << "delete:" << fileName << "||" << funcName << "||" << lineNo << "||" << p << endl;
//  ::operator delete(p);
//}
 
// 重载operator delete
void operator delete(void* p)
{
  cout << "delete:" << endl;
  free(p);
}
 
#ifdef _DEBUG
     #define new new(__FILE__, __FUNCTION__, __LINE__)
     // #define delete(p) operator delete(p, __FILE__, __FUNCTION__, __LINE__) 不实现这个宏，不然使用要加（）
#endif
 
int main()
{
  A* p1 = new A;
  delete p1;
 
  A* p2 = new A[4];
  delete[] p2;
 
  A* p3 = new A;
  delete p3;
 
  A* p4 = new A;
  delete p4;
 
  A* p5 = new A;
  delete p5;
 
    return 0;
}

// new -> operator new + 构造函数
// 默认情况下operator new使用全局库里面
// 每个类可以去实现自己专属operator new  new这个类对象，他就会调自己实现这个operator new
 
// 实现一个类专属的operator new  -- 了解一下
 
#include<iostream>
using namespace std;
 
class A
{
public:
  A(int a = 0)
    : _a(a)
  {
    cout << "A():" << this << endl;
  }
 
  ~A()
  {
    cout << "~A():" << this << endl;
  }
 
private:
  int _a;
};
 
struct ListNode
{
  int _val;
  ListNode* _next;
 
  static allocator<ListNode> alloc;// 内存池
 
  void* operator new(size_t n)
  {
    cout << "operator new -> STL内存池allocator申请" << endl;
    void* obj = alloc.allocate(1);
    return obj;
  }
 
  void operator delete(void* ptr)
  {
    cout << "operator delete -> STL内存池allocator申请" << endl;
 
    alloc.deallocate((ListNode*)ptr, 1);
  }
 
  struct ListNode(int val)
    :_val(val)
    , _next(nullptr)
  {}
};
 
// allocator以后会讲，现在先了解即可
allocator<ListNode> ListNode::alloc;
 
int main()
{
  // 频繁申请ListNode. 想提高效率 -- 申请ListNode时，不去malloc，而是自己定制内存池
  ListNode* node1 = new ListNode(1);
  ListNode* node2 = new ListNode(2);
  ListNode* node3 = new ListNode(3);
 
  delete node1;
  delete node2;
  delete node3;
 
  A* p1 = new A;
 
  return 0;
}