另一个动态加载DLL包装

...

    // Try to load the library

    if (0 == psapi_load())

        return;



    // Check whether the symbol was loaded

    if (! pGetProcessImageFileNameW)

        return;



    TCHAR sName1[1024];

    pGetProcessImageFileNameW(GetCurrentProcess(), sName1, 1024);

...

//! Interface class for dexplicit and implicit linking and loading of dlls

//! and contained symbols.

class CDynlinkLib

{

    friend class CDynlinkSymbol;

public:

    //! Mode of loading

    enum mode

    {

        //! Explicit loading of function addresses

        ex,

        //! Explicit loading with stubs

        exstub,

        //! Implicit loading.

        imp

    };



    //! Create a library interface. 

    //! @param sName

    //!        The name of the library. (e.g. psapi for psapi.dll)

    //! @param d_mode

    //!        The mode (see above). 

    CDynlinkLib(LPCWSTR sName, mode d_mode = ex);

    CDynlinkLib(LPCSTR  sName, mode d_mode = ex);



    //! Get error during library load

    //! @param s_err

    //!        The string to write a formatted error message to

    //! @return 

    //!        The error as returned by GetLastError() during the load_library call.

    DWORD get_error() const

    {

        return m_dwError;

    }



    //! If set to true defined, accessing a variable or function not loaded 

    //! will cause a c++ exception to be thrown. In fact, the symbol throws a 

    //! pointer to itself so you could wrap your code accessing the lib into

    //! try 

    //! {

    //!        code;

    //! }

    //! catch (CDynlinkSymbol * p)

    //! {

    //!        retrive and display error information;

    //! }

    //! REMARK: this will also occur if you just check the symbol against NULL. If 

    //! this is enabled use the is_loaded() function instead to avoid throwing an 

    //! exception.

#ifndef DYNLINK_NO_THROW

    void set_throw(bool b_throw)

    {

        m_b_throw = b_throw;

    }

#endif



    //! Load the library and all symbols. For details see above.

    //! @param bRetry

    //!        Retry the load independently of previous results. If not TRUE 

    //!        a loaded library and its symbols will not be touched.

    //!    @param sName

    //!        Replace the library name given above.

    //! @return 

    //!        State of the loading, see definitions of DYNLINK_ERR ... above

    int load(LPCWSTR sName = 0, BOOL bRetry = FALSE);



    int load(LPCSTR sName, BOOL bRetry = FALSE);

    

    //! Get loading state.

    //! @return 

    //!        State of the loading, see definitions of DYNLINK_ERR ... above

    int get_state() const

    {

        return m_dLoaded;

    }

    //! Get the loading mode of the library object. See CDynlinkLib::mode for

    //! details.

    //! @return

    //!        the mode with which the library was loaded.



    mode get_mode() const

    {

        return m_mode;

    }

    //! Check whether the library was loaded successfully.

    //! @return

    //!        true if get_state() is DYNLINK_SUCCESS

    bool is_loaded() const

    {

        return (get_state() == DYNLINK_SUCCESS);

    }



    //! Check whether all symbols can be called in the library without NULLPTR

    //! references.

    //! @return

    //!        true if get_state() is either DYNLINK_SUCCESS or DYNLINK_ERR_STUBS

    bool is_loaded_or_stub() const

    {

        return (get_state() == DYNLINK_SUCCESS) || (get_state() == DYNLINK_ERR_STUBS);

    }



    //! Unload the library. This will fail for an implicitely linked library

    //! but should succeed for explicite linkage and delayed loading.

    bool free();



    //! Add a symbol.

    //! @param p_sym

    //!        Symbol to load as part of this library module

    void add(CDynlinkSymbol * p_sym);



    //! Get the module handle for a successfully loaded library. NULL if the 

    //! library was not loaded.

    //! REMARK: when implicitely linking, this may return NULL even if the 

    //! library was successfully loaded but if the module name does not match

    HMODULE get_module() const

    {

        return m_hDll;

    }



    //! Get the filename of the library loaded. Can fail for implicitely linked

    //! libs if the library name is not correct

    BOOL get_filename(dynlink_string_w &s_fn) const;

    //! Get the filename of the library loaded.

    BOOL get_filename(dynlink_string_a &s_fn) const;

protected:

...

};