Петцольд OLE IMalloc - C/C++ - Ответ 13979422

#ifndef IMALLOC_H
 
#define IMALLOC_H
 
#include <windows.h>
 
//======================================================================
#define EXPORT extern "C" __declspec(dllexport)
 
EXPORT LPMALLOC CreateAllocator ();
 
#undef INTERFACE
#define INTERFACE DAlloc
 
//======================================================================
DECLARE_INTERFACE_(DAlloc, IMalloc)
{
  // IUnknown
  STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID FAR* ppv);
  STDMETHOD_(ULONG, AddRef)(THIS);
  STDMETHOD_(ULONG, Release)(THIS);
 
  // IMalloc
  STDMETHOD_(void*, Alloc)(THIS_ ULONG cb);
  STDMETHOD_(void*, Realloc)(THIS_ void* pv, ULONG cb);
  STDMETHOD_(void, Free)(THIS_ void* pv);
  STDMETHOD_(ULONG, GetSize)(THIS_ void* pv);
  STDMETHOD_(int, DidAlloc)(THIS_ void* pv);
  STDMETHOD_(void, HeapMinimize)(THIS);
 
#ifndef CINTERFACE
  private:
    ULONG m_uiRefCnt = 0;
    HANDLE m_handle = nullptr;
 
  public:
    DAlloc () = default;
 
    bool Initialize ();
 
    ~DAlloc ();
#endif
};
 
//======================================================================
#endif

#include "IMalloc.h"
 
//======================================================================
EXPORT LPMALLOC CreateAllocator ()
{
  auto pDAlloc = new DAlloc();
  if (pDAlloc->Initialize())
    pDAlloc->AddRef();
  else
  {
    delete pDAlloc;
    pDAlloc = nullptr;
  }
  return reinterpret_cast<LPMALLOC>(pDAlloc);
}
 
//======================================================================
STDMETHODIMP DAlloc::QueryInterface (REFIID riid, LPVOID FAR* ppv)
{
  *ppv = nullptr;
 
  if (riid == IID_IUnknown)
    *ppv = reinterpret_cast<IUnknown*>(this);
  else if (riid == IID_IMalloc)
    *ppv = reinterpret_cast<IMalloc*>(this);
 
  if (*ppv)
  {
    AddRef();
    return S_OK;
  }
  return E_NOINTERFACE;
}
 
//======================================================================
STDMETHODIMP_(ULONG) DAlloc::AddRef ()
{ return ++m_uiRefCnt; }
 
//======================================================================
STDMETHODIMP_(ULONG) DAlloc::Release ()
{
  if (!--m_uiRefCnt)
  {
    delete this;
    return 0;
  }
  return m_uiRefCnt;
}
 
//======================================================================
STDMETHODIMP_(void*) DAlloc::Alloc (ULONG cb)
{ return HeapAlloc(m_handle, HEAP_ZERO_MEMORY, cb); }
 
//======================================================================
STDMETHODIMP_(void*) DAlloc::Realloc (void* pv, ULONG cb)
{ return HeapReAlloc(m_handle, HEAP_ZERO_MEMORY, pv, cb); }
 
//======================================================================
STDMETHODIMP_(void) DAlloc::Free (void* pv)
{ HeapFree(m_handle, 0, pv); }
 
//======================================================================
STDMETHODIMP_(ULONG) DAlloc::GetSize (void* pv)
{ return HeapSize(m_handle, 0, pv); }
 
//======================================================================
STDMETHODIMP_(int) DAlloc::DidAlloc (void* pv)
{
  PROCESS_HEAP_ENTRY phe;
  ZeroMemory(&phe, sizeof(phe));
 
  while (HeapWalk(m_handle, &phe))
    if (phe.lpData == pv)
      return true;
  return false;
}
 
//======================================================================
STDMETHODIMP_(void) DAlloc::HeapMinimize ()
{ HeapCompact(m_handle, 0); }
 
//======================================================================
bool DAlloc::Initialize ()
{
  m_handle = HeapCreate(0, 4096, 65535);
  return m_handle;
}
 
//======================================================================
DAlloc::~DAlloc ()
{
  if (m_handle)
    HeapDestroy(m_handle);
}

#include "IMalloc.h"
 
//==================================================================================
int WINAPI WinMain (_In_     HINSTANCE,
                    _In_opt_ HINSTANCE,
                    _In_     LPSTR,
                    _In_     int)
{
  auto pMalloc = CreateAllocator();
 
  return 0;
}