使用IMalloc接口来分配内存演示程序

来源：互联网发布：java的接口修饰符编辑：程序博客网时间：2024/06/06 16:12

使用IMalloc接口来分配内存演示程序

借助一个Win32程序展示了如何利用OLE的IMalloc接口来分配任务类型和共享类型的内存。

程序运行画面如下：

源码MALLOC.H：

#ifndef _MALLOC_H_ 
#define _MALLOC_H_ 
LRESULT PASCAL MallocWndProc(HWND, UINT, WPARAM, LPARAM);
#define CALLOCS 10 
/*
 * Application defined classes and types.
 */
class CAppVars
{
    friend LRESULT PASCAL MallocWndProc(HWND, UINT, WPARAM, LPARAM);
protected:
    HINSTANCE   m_hInst;
    HINSTANCE   m_hInstPrev;
    UINT        m_nCmdShow;
    HWND        m_hWnd;
    LPMALLOC    m_pIMalloc;
    BOOL        m_fInitialized;
    ULONG       m_rgcb[CALLOCS];   //Sizes to allocate 
    LPVOID      m_rgpv[CALLOCS];   //Allocated pointers 
public:
    CAppVars(HINSTANCE, HINSTANCE, UINT);
    ~CAppVars(void);
    BOOL FInit(void);
    void FreeAllocations(BOOL);
};
typedef CAppVars FAR* LPAPPVARS;
#define CBWNDEXTRA          sizeof(LONG) 
#define MALLOCWL_STRUCTURE  0 
#endif // _MALLOC_H_

如下是MALLOC.CPP文件内容：

#include <windows.h> 
#include <ole2.h> 
#include <initguid.h> 
#include <ole2ver.h> 
#include "malloc.h" 
#include "resource.h" 
int PASCAL WinMain(HINSTANCE hInst, HINSTANCE hInstPrev, LPSTR pszCmdLine, int nCmdShow)
{
    MSG         msg;
    LPAPPVARS   pAV;
    int         cMsg = 96;
#ifndef WIN32 
    while(!SetMessageQueue(cMsg) && (cMsg-=8));
#endif 
    pAV = new CAppVars(hInst, hInstPrev, nCmdShow);
    if(NULL == pAV)
    {
        return -1;
    }
    if(pAV->FInit())
    {
        while(GetMessage(&msg, NULL, 0, 0))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    delete pAV;
    return msg.wParam;
}
LRESULT PASCAL MallocWndProc(HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
    LPAPPVARS   pAV;
    LPVOID      pv;
    ULONG       cb;
    UINT        i;
    BOOL        fResult = TRUE;
    HRESULT     hr;
    pAV = (LPAPPVARS)GetWindowLong(hWnd, MALLOCWL_STRUCTURE);
    switch(iMsg)
    {
    case WM_NCCREATE:
        pAV = (LPAPPVARS)((LONG)((LPCREATESTRUCT)lParam)->lpCreateParams);
        SetWindowLong(hWnd, MALLOCWL_STRUCTURE, (LONG)pAV);
        return (DefWindowProc(hWnd, iMsg, wParam, lParam));
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    case WM_COMMAND:
        switch(LOWORD(wParam))
        {
        case IDM_IMALLOCCOGETMALLOCTASK:
            pAV->FreeAllocations(TRUE);
            hr = CoGetMalloc(MEMCTX_TASK, &pAV->m_pIMalloc);
            fResult = SUCCEEDED(hr);
            MessageBox(hWnd, ((fResult)? TEXT("CoGetMalloc(task) succeeded."):TEXT("CoGetMalloc(task) failed.")), 
                TEXT("MALLOC"), MB_OK);
            break;
        case IDM_IMALLOCCOGETMALLOCSHARED:
            pAV->FreeAllocations(TRUE);
            hr=CoGetMalloc(MEMCTX_SHARED, &pAV->m_pIMalloc);
            fResult = SUCCEEDED(hr);
            MessageBox(hWnd, ((fResult)?TEXT("CoGetMalloc(shared) succeeded."):TEXT("CoGetMalloc(shared) failed.")), 
                TEXT("MALLOC"), MB_OK);
            break;
        case IDM_IMALLOCRELEASE:
            pAV->FreeAllocations(TRUE);
            MessageBox(hWnd, TEXT("IMalloc::Release finished."), TEXT("Malloc"), MB_OK);
            break;
        case IDM_IMALLOCALLOC:
            if(NULL == pAV->m_pIMalloc)
                break;
            pAV->FreeAllocations(FALSE);
            for(i=0; i<CALLOCS; i++)
            {
                LPBYTE  pb;
                ULONG   iByte;
                cb = pAV->m_rgcb[i];
                pAV->m_rgpv[i]=pAV->m_pIMalloc->Alloc(cb);
                //Fill the memory with letters 
                pb=(LPBYTE)pAV->m_rgpv[i];
                if(NULL!=pb)
                {
                    for(iByte=0; iByte<cb; iByte++)
                    {
                        *pb++=('a'+i);
                    }
                }
                fResult &= (NULL!=pAV->m_rgpv[i]);
            }
            MessageBox(hWnd, ((fResult)?TEXT("IMalloc::Alloc succeeded."):TEXT("IMalloc::Alloc failed.")), 
                TEXT("MALLOC"), MB_OK);
            break;
        case IDM_IMALLOCFREE:
            pAV->FreeAllocations(FALSE);
            MessageBox(hWnd, TEXT("IMalloc::Free finished."), TEXT("Malloc"), MB_OK);
            break;
        case IDM_IMALLOCREALLOC:
            if(NULL == pAV->m_pIMalloc)
                break;
            for(i=0; i<CALLOCS; i++)
            {
                LPBYTE      pb;
                ULONG       iByte;
                pAV->m_rgcb[i]+=128;
                pv=pAV->m_pIMalloc->Realloc(pAV->m_rgpv[i], pAV->m_rgcb[i]);
                if(NULL!=pv)
                {
                    pAV->m_rgpv[i]=pv;
                    //Fill the new memory with something we can see. 
                    pb=(LPBYTE)pAV->m_rgpv[i];
                    cb=pAV->m_rgcb[i];
                    if(NULL!=pb)
                    {
                        for(iByte=cb-128; iByte<cb; iByte++)
                        {
                            *pb++=('a'+i);
                        }
                    }
                }
                else
                {
                    fResult  = FALSE;
                }
            }
            MessageBox(hWnd, ((fResult)?TEXT("IMalloc::Realloc succeeded."):TEXT("IMalloc::Realloc failed.")), 
                TEXT("Malloc"), MB_OK);
            break;
        case IDM_IMALLOCGETSIZE:
            if(NULL==pAV->m_pIMalloc)
            {
                break;
            }
            for(i=0; i<CALLOCS; i++)
            {
                cb = pAV->m_pIMalloc->GetSize(pAV->m_rgpv[i]);
                /*
                 * We test that the size is at least what we wanted.
                 */
                fResult &= (pAV->m_rgcb[i] <= cb);
            }
            MessageBox(hWnd, ((fResult)?TEXT("IMalloc::GetSize matched."):TEXT("IMalloc::GetSize mismatch.")),
                TEXT("Malloc"), MB_OK);
            break;
        case IDM_IMALLOCDIDALLOC:
            if(NULL==pAV->m_pIMalloc)
                break;
            /*
             * DidAlloc may return -1 if it does not know if
             * it actually allocated something. In that case,
             * we just blindly & in a -1 with no effect.
             */
            for(i=0; i<CALLOCS; i++)
            {
                fResult &= pAV->m_pIMalloc->DidAlloc(pAV->m_rgpv[i]);
            }
            MessageBox(hWnd, ((fResult)?TEXT("IMalloc::DidAlloc is TRUE."):TEXT("IMalloc::DidAlloc is FALSE.")), 
                TEXT("IMalloc"), MB_OK);
            break;
        case IDM_IMALLOCHEAPMINIMIZE:
            if(NULL!=pAV->m_pIMalloc)
            {
                pAV->m_pIMalloc->HeapMinimize();
            }
            MessageBox(hWnd, TEXT("IMalloc::HeapMinimize finished."), TEXT("Malloc"), MB_OK);
            break;
        case IDM_IMALLOCEXIT:
            PostMessage(hWnd, WM_CLOSE, 0, 0L);
            break;
        }
        break;
    default:
        return (DefWindowProc(hWnd, iMsg, wParam, lParam));
    }
    return 0L;
}
CAppVars::CAppVars(HINSTANCE hInst, HINSTANCE hInstPrev, UINT nCmdShow)
{
    UINT    i;
    ULONG   cb;
    //Initialize WinMain parameter holders. 
    m_hInst = hInst;
    m_hInstPrev = hInstPrev;
    m_nCmdShow = nCmdShow;
    m_hWnd = NULL;
    m_pIMalloc = NULL;
    m_fInitialized = FALSE;
    
    // 100 is arbitrary. IMalloc can handle larger. 
    cb = 100;
    for(i=0; i<CALLOCS; i++)
    {
        m_rgcb[i] = cb;
        m_rgpv[i] = NULL;
        cb*=2;
    }
    return;
}
CAppVars::~CAppVars(void)
{
    FreeAllocations(TRUE);
    //free the enumerator object if we have one. 
    if(m_fInitialized)
    {
        CoUninitialize();
    }
    return;
}
BOOL CAppVars::FInit()
{
    WNDCLASS    wc;
    DWORD       dwVer;
    //Make sure COMPOBJ.DLL is the right version 
    dwVer = CoBuildVersion();
    if(rmm != HIWORD(dwVer) )
        return FALSE;
    //Call CoInitialize so that we can call other Co... functions 
    if(FAILED(CoInitialize(NULL)))
        return FALSE;
    m_fInitialized = TRUE;
    if(!m_hInstPrev)
    {
        wc.style = CS_HREDRAW | CS_VREDRAW;
        wc.lpfnWndProc = MallocWndProc;
        wc.cbClsExtra = 0;
        wc.cbWndExtra = CBWNDEXTRA;
        wc.hInstance = m_hInst;
        wc.hIcon = LoadIcon(m_hInst, TEXT("Icon"));
        wc.hCursor = LoadCursor(NULL, IDC_ARROW);
        wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
        wc.lpszMenuName = MAKEINTRESOURCE(IDR_MENU1);
        wc.lpszClassName = TEXT("MALLOC");
        if(!RegisterClass(&wc))
            return FALSE;
    }
    m_hWnd = CreateWindow(TEXT("MALLOC"), TEXT("IMalloc Object Demo"),
        WS_OVERLAPPEDWINDOW, 35, 35, 350, 250, NULL, NULL, m_hInst, this);
    if(NULL == m_hWnd)
    {
        return FALSE;
    }
    ShowWindow(m_hWnd, m_nCmdShow);
    UpdateWindow(m_hWnd);
    return TRUE;
}
void CAppVars::FreeAllocations(BOOL fRelease)
{
    UINT i;
    if(NULL == m_pIMalloc)
    {
        return;
    }
    for(i=0; i<CALLOCS; i++)
    {
        if(NULL!=m_rgpv[i])
            m_pIMalloc->Free(m_rgpv[i]);
        m_rgpv[i] = NULL;
    }
    if(fRelease)
    {
        m_pIMalloc->Release();
        m_pIMalloc = NULL;
    }
}

任务型内存调用顺序大致如下：

CoGetMalloc(Task,...)	得到任务类型接口指针
Alloc	分配任务型内存
Realloc	再分配，扩充内存
GetSize	得到内存块大小
DidAlloc	确认内存是否已经分配
HeapMinimize	优化堆大小
Free	释放已经分配的内存
Release	释放接口指针

共享型内存调用顺序大致如下：

CoGetMalloc(Shared,...)	得到共享类型接口指针
Alloc	分配共享型内存
Realloc	再分配，扩充内存
GetSize	得到内存块大小
DidAlloc	确认内存是否已经分配
HeapMinimize	优化堆大小
Free	释放已经分配的内存
Release	释放接口指针

但是很不幸的是，我发现CoGetMalloc, 使用MEMCTX_SHARED即2作为dwMemContext参数进行调用,根本不能成功，如果你强行传入MEMCTX_SHARED，那么你将得到E_INVALIDARG这个错误。也就是说共享类型接口指针根本是胡扯啦~~~

HRESULT CoGetMalloc(DWORD dwMemContext, LPMALLOC * ppMalloc); MSDN上已经明文指定：dwMemContext [in] Reserved; value must be 1.即MEMCTX_TASK。by Loomman, QQ:28077188, MSN: Loomman@hotmail.com QQ裙：30515563 ☆程序天堂☆ 请尊重作者原创，转载注明来自裂帛一剑博客，谢谢合作。