BOOL APIENTRY DllMain(HANDLE hModule, 
                      DWORD  dwReason
                      LPVOID lpReserved)
{
    return TRUE;
}

__>>BOOL APIENTRY DllMain(HANDLE hModule, 
__>>                      DWORD  dwReason
__>>                      LPVOID lpReserved)
__>>{
__>>    return TRUE;
__>>}
__>>

// Dummy.h
#ifdef DUMMY_EXPORTS
#define DUMMY_API __declspec(dllexport)
#else
#define DUMMY_API __declspec(dllimport)
#endif

#include <windows.h>

namespace Dummy_Interface {
    // An abstract interface.
    class DUMMY_API IDummyInterface {
    public:
        virtual void hello(const char* name) = 0;
        virtual void goodbye() = 0;
    };

    // Interface's rountines for the explicit linking...
    DUMMY_API int APIENTRY Load(IDummyInterface ** pInterface);
    DUMMY_API int APIENTRY Unload(IDummyInterface ** pInterface);

    // Pointers to the interface's rountines
    typedef int (APIENTRY* PFNLOAD)(IDummyInterface**);
    typedef int (APIENTRY* PFNUNLOAD)(IDummyInterface**);

    // The Dummy interface.
    class DUMMY_API IDummy : public IDummyInterface {
    public:
        enum Max_char { max = 32 };        // the maximumum name's lenght

        IDummy() { p = new char[max]; }
        ~IDummy() { delete[] p; }

        void hello(const char* name = szDefName);
        void goodbye();

        static const char szDefName[max]; // the default user's name
    private:
        char* p; // a pointer to the user's name
    };
}


// Globals
extern DUMMY_API int address;

DUMMY_API void APIENTRY Increment(int&);

// dummy.cpp : Defines the entry point for the DLL application.
//

#include "stdafx.h"
#include "dummy.h"

BOOL APIENTRY DllMain(HANDLE hModule, 
                      DWORD  dwReason, 
                      LPVOID lpReserved)
{
    static Dummy_Interface::IDummy* dum;

    switch (dwReason) {
        case DLL_PROCESS_ATTACH:
            {
                dum = new Dummy_Interface::IDummy();
                dum->hello();
            }
            break;

        case DLL_PROCESS_DETACH:
            {
                dum->goodbye();
                delete dum;
            }
            break;
    }
    return TRUE;
}

// Пример "экспорта" функции.
void APIENTRY Increment(int& x) { x++; }

// Экспортируемая глобальная переменная.
int address = 0x00FA;



// Инициализация статической переменной класса.
const char Dummy_Interface::IDummy::szDefName[IDummy::max] = "Lamer";

// Инициализация "интерфейса" IDummy, только при неявной загрузке DLL.
// Не использовать при явном связываннии DLL.
int APIENTRY Dummy_Interface::Load(Dummy_Interface::IDummyInterface ** pInterface)
{
    if (!*pInterface)
        return -1;

    *pInterface = reinterpret_cast<IDummyInterface*>(new IDummy);
    return 0;
}


// Очистка "интерфейса" IDummy, только при неявной загрузке DLL.
// Не использовать при явном связываннии DLL.
int APIENTRY Dummy_Interface::Unload(Dummy_Interface::IDummyInterface ** pInterface)
{
    if (!*pInterface)
        return -1;

    delete *pInterface;
    *pInterface = 0;
    return 0;
}

// Выводит сообщение формата: "Hello, name!", где name - произвольное
// имя (может быть опущено, в этом случае используется аргумент по
// умолчанию - szDefName).
void Dummy_Interface::IDummy::hello(const char* name)
{
    char* base = p;
    for (char* pch=(char*)name; *pch!=0; *p++ = *pch++);
    *p++ = '!';
    *p = 0;
    p = base;

    char out[100] = "Hello, ";
    lstrcat(out, p);
    MessageBox(
        NULL,
        out,
        "Dummy_Interface",
        MB_OK|MB_ICONEXCLAMATION);
}

// Делает то-же, что и hello, за исключением того, что формат выволимой
// строки меняется на: "Goodbye, name!".
void Dummy_Interface::IDummy::goodbye()
{
    char out[100] = "Goodbye, ";
    lstrcat(out, p);
    MessageBox(
        NULL,
        out,
        "Dummy_Interface",
        MB_OK|MB_ICONEXCLAMATION);
}

// Где-то в программе.....
HMODULE hDummy = LoadLibrary("dummy.dll");

// См. примечание ниже.
PFNLOAD pfnLoad = (PFNLOAD)GetProcAddress(hDummy, "Load");
PFNUNLOAD pfnUnload = (PFNUNLOAD)GetProcAddress(hDummy, "Unload");

Dummy_Interface::IDummyInterface* dum; // "интерфейс"
pfnLoad(&dum);                         // инициализация...
dum->Dummy_Interface::hello("Boomer"); // использование...
dum->Dummy_Interface::goodbye();
pfnUnload(&dum);                       // очистка...

FreeLibrary(hDummy); // выгружаем DLL из адресного пространства процесса

PFNLOAD pfnLoad = (PFNLOAD)GetProcAddress(
    hDummy,
    "?Load@Dummy_Interface@@YGHPAPAVIDummyInterface@1@@Z");

PFNUNLOAD pfnUnload = (PFNUNLOAD)GetProcAddress(
    hDummy,
    "?Unload@Dummy_Interface@@YGHPAPAVIDummyInterface@1@@Z");

DESCRIPTION        'Dummy DLL for Win32 API'
LIBRARY            dummy.dll
EXPORTS
    Load            @1
    Unload          @2
    hello           @3
    goodbye         @4
    Increment       @5
    szDefName       @6
    address         @7