Code:

typedef HANDLE (*MOJAPROCEDURA)(enum, unsigned int);

MOJAPROCEDURA proc1;

todo: loadlibrary() i ostalo...

proc1 = (MOJAPROCEDURA)GetProcAddress( ... )

i pozivas kao:

(proc1)( parametri )...

Code:


// svi include fajlovi ...
#include <nesto.h>
#include <svasta.h>

//struktura koja ce drzati sve pointere na funkcije
//(volim da pisem ovakve stvari

struct FUNC_TABLE_T
{
    char *name;
    void *func;
}lib_table[] = {
    {"nitialize_something",NULL},
    {"end_something",NULL},
    {"assign_something", NULL},
    {"remove_something",NULL},
    {"get_something", NULL},
    {NULL,NULL}
};

//globalna promenljiva koja ce imati pointer na otvoreni dll

HMODULE hndl_api = NULL;

int main (int argc, char **argv)
{

//definicije i prototipi
//naime, ovde pravis definises kako ce izgledati prototip funkcije koju ces da
//loadas iz dll-a sa tacnim parametrima koje ce funkcija da primi, i sa tipom
//promenljive koju ce funkcija da ti vrati

    typedef int (*FPROT1) (char*, char*);
    typedef int (*FPROT2) (void, unsigned long);
    typedef int (*FPROT3) (char*);
    typedef char* (*FPROT4) ();

//placeholderi za pointer na funkciju:

    FPROT1 initialize_something;
    FPROT2 end_something;
    FPROT3 assign_something;
    FPROT3 remove_something;
    FPROT4 get_something;

//ovde pokusavas da otvoris handle na dll, ako nema dll-a ode sve u pm.
//naravno, dll treba da bude ili u windows system direktoriju, ili u diru odakle
//radi tvoj softver

    hndl_api = LoadLibrary(_T("neki.dll"));
    if(hndl_api == NULL)
    {
        printf("dll ne postoji. bla bla bla\n");
        return 0;
    }

//ovde mapiras void pointere funkcija iz dll-a u strukturu koja je definisana
//ranije 
    lib_table[0].func = (void *) GetProcAddress (hndl_api, lib_table[0].name); 
    lib_table[1].func = (void *) GetProcAddress (hndl_api, lib_table[1].name); 
    lib_table[2].func = (void *) GetProcAddress (hndl_api, lib_table[2].name); 
    lib_table[3].func = (void *) GetProcAddress (hndl_api, lib_table[3].name); 
    lib_table[4].func = (void *) GetProcAddress (hndl_api, lib_table[4].name);

    if(lib_table[0].func == NULL ||
       lib_table[1].func == NULL ||
       lib_table[2].func == NULL ||
       lib_table[3].func == NULL ||
       lib_table[4].func == NULL)
    {
         printf("funkcije pogresno izmapirane, ili ne postoje...\n");
          return 0;
    }

//za coup de grace: casting void pointera na funkcije prema prototipu koji
//je definisan

    initialize_something = (FPROT1) lib_table[0].func;
    end_something = (FPROT2) lib_table[1].func;
    assign_something = (FPROT3) lib_table[2].func;
    remove_something = (FPROT3) lib_table[3].func;
    get_something = (FPROT4) lib_table[4].func;
    
//sada mozes da koristis te funkcije koje si izmapirao iz dll-a:

    if ((*initialize_something) (argv[1], argv[2]) <0)
    {
        printf("nesto nije u redu ...\n");
        return 0;
    }

//ovde ide puno koda koji radi nesto sa svim tim funkcijama

//oslobodi pointer na library
    FreeLibrary(hndl_api);

//kraj
    return 0;
}

Code:

#DllExports.h koji sam napisao pre par meseci bas za takav slucaj
#ifndef DLLEXPORTS_H
#define DLLEXPORTS_H

#ifdef __dll__
#define IMPEXP __declspec(dllexport)
#else
#define IMPEXP __declspec(dllimport)
#endif     // __dll__

#include "ObjStorage.h"
#include "ObjStorageInterface.h"

extern "C"
{
    IMPEXP ITestObject* CreateTestObjectClassInstance();
}
#endif    // DLLEXPORTS_H

Code:

        //here write the object stream !!!!
        try
        {
            typedef ITestObject* (*FPROT1) ();
            HINSTANCE hndl = NULL;
            FPROT1 Ser;
            ITestObject* pTestObject = NULL;

            hndl = LoadLibrary("ObjStorage.dll");
            Ser = (FPROT1) (GetProcAddress(hndl, "CreateTestObjectClassInstance"));

            pTestObject =  /*static_cast<ITestObject*>*/ (Ser());

            (*pTestObject).Serialize(tmp);
            
            FreeLibrary (hndl);
        }
        catch(...)
        {
            cout << "Attempt at loading object and serialization failed!\n";
            cout.flush();
            return 0;
        }

Code:

class __declspec(dllexport) ITestObject
{
public:
    virtual void Serialize(char*) = 0;
    virtual void DeSerialize(char*) = 0;
};