C++モニタメモリ割り当て

見たことがありますhttp://www.almostinfinite.com/memtrack.html中のコードは自分で書き直しました.
mem.h

#pragma once
#include
namespace MemTrack
{ 
 struct MemInfo
 {
   unsigned int m_line;
  const char* m_file;
  MemInfo()
  {}
  MemInfo(unsigned int iLine, const char* cFile):m_line(iLine),m_file(cFile)
  {
  }
  MemInfo(const MemInfo & meminfo) :m_line(meminfo.m_line), m_file(meminfo.m_file)
  {
  }
  };
 void* TrackAlloc(size_t size);
 void TrackFree(void* p);
 void DisplayMem();
 template<class T>inline T* operator*(const MemInfo& meminfo, T* p)
 {
  BlockNode*pnode=(BlockNode*)GetBlockAddr(p);
  pnode->m_meminfo = meminfo;
  return p;
 }
 struct BlockNode
 {
  BlockNode* m_pNextNode;
  BlockNode* m_pPrevNode;
  MemInfo m_meminfo;
  size_t m_dataSize;
  BlockNode():m_pNextNode(nullptr), m_pPrevNode(nullptr)
  {}
  BlockNode(size_t size):m_pNextNode(nullptr), m_pPrevNode(nullptr),\
   m_dataSize(size)
  {
  }
 };
 class BlockStruct
 {
 public:
  static void PushFront(BlockNode* node)
  {
   if (m_BlockHeader)
   {
    node->m_pNextNode = m_BlockHeader;
    m_BlockHeader->m_pPrevNode = node;
   }
   m_BlockHeader = node;
  }
  static void PopNode(BlockNode *pnode)
  {
   BlockNode* PrevNode = pnode->m_pPrevNode;
   BlockNode* NextNode = pnode->m_pNextNode;
   if (PrevNode)
   {
    PrevNode->m_pNextNode= NextNode;
   }
   else
   {
    m_BlockHeader = NextNode;
   }
   if (NextNode)
    NextNode->m_pPrevNode = PrevNode;
  }
  static void GetAllelemts()
  {
   BlockNode* pnode = m_BlockHeader;
   while(pnode)
   {
    std::cout <<"Line:"<< pnode->m_meminfo.m_line << " Mem:" << pnode->m_dataSize << std::endl;
    pnode = pnode->m_pNextNode;
   }
  }
 private:
  static BlockNode* m_BlockHeader;
 };
 inline BlockNode* GetBlockAddr(void* p)
 {
  return (BlockNode*)((char*)p - sizeof(BlockNode));
 }
}
#define MemTrackNew MemTrack::MemInfo(__LINE__,__FILE__)* new
#define new MemTrackNew

mem.cpp

#include "mem.h"
#include 
#include 
#undef new
namespace MemTrack
{
 void* TrackAlloc(size_t size)
 {
  void *p = malloc(sizeof(BlockNode)+size);
  BlockNode* pNode = new (p) BlockNode(size);
  BlockStruct::PushFront(pNode);
  if (!p)throw std::bad_alloc();
  return (char*)p+ sizeof(BlockNode);
 }
 void TrackFree(void* p)
 {
  BlockNode *pnode = (BlockNode*)GetBlockAddr(p);
  BlockStruct::PopNode(pnode);
  free(pnode);
 }
 void DisplayMem()
 {
  BlockStruct::GetAllelemts();
 }
 BlockNode* BlockStruct::m_BlockHeader = nullptr;
};
void* operator new(size_t size)
{
 void *p= MemTrack::TrackAlloc(size);
 return p;
}
void operator delete(void *p)
{
 MemTrack::TrackFree(p);
}
void *operator new[](size_t size)
{
 void *p = MemTrack::TrackAlloc(size);
 return p;
}
void operator delete[](void *p)
{
 MemTrack::TrackFree(p);
}

テストコード

 MYStruct* a = new MYStruct;
 MYStruct* b = new MYStruct;
 int* c = new int;
 delete b;
 c = new int;
 c = new int;
 c = new int;
 c = new int;
 MemTrack::DisplayMem();

運転結果