Dynamically load a function from a DLL

Question

I m having a little look at  dll files  I understand their usage and I m trying to understand how to use them   I have created a  dll file that contains a function that returns an integer named funci    using this code  I  think  I ve imported the  dll file into the project there s no complaints     include  lt windows h gt   include  lt iostream gt   int main       HINSTANCE hGetProcIDDLL   LoadLibrary  C   Documents and Settings  User  Desktop    fgfdg  dgdg  test dll       if  hGetProcIDDLL    NULL        std  cout  lt  lt   cannot locate the  dll file   lt  lt  std  endl      else       std  cout  lt  lt   it has been called   lt  lt  std  endl      return -1         int a   funci       return a       funci function   int funci       return 40      However when I try to compile this  cpp file that I think has imported the  dll I have the following error    C  Documents and Settings User Desktop fgfdg onemore cpp  In function  int main      C  Documents and Settings User Desktop fgfdg onemore cpp 16 error   funci  was not     declared in this scope        Build finished  1 errors  0 warnings        I know a  dll is different from a header file so I know I can t import a function like this but it s the best I could come up with to show that I ve tried   My question is  how can I use the hGetProcIDDLL pointer to access the function within the  dll    I hope this question makes sense and I m not barking up some wrong tree yet again

User · Answer

In addition to the already posted answer, I thought I should share a handy trick I use to load all the DLL functions into the program through function pointers, without writing a separate GetProcAddress call for each and every function. I also like to call the functions directly as attempted in the OP.

Start by defining a generic function pointer type:

typedef int (__stdcall* func_ptr_t)();

What types that are used aren't really important. Now create an array of that type, which corresponds to the amount of functions you have in the DLL:

func_ptr_t func_ptr [DLL_FUNCTIONS_N];

In this array we can store the actual function pointers that point into the DLL memory space.

Next problem is that GetProcAddress expects the function names as strings. So create a similar array consisting of the function names in the DLL:

const char* DLL_FUNCTION_NAMES [DLL_FUNCTIONS_N] = 
{
  "dll_add",
  "dll_subtract",
  "dll_do_stuff",
  ...
};

Now we can easily call GetProcAddress() in a loop and store each function inside that array:

for(int i=0; i<DLL_FUNCTIONS_N; i++)
{
  func_ptr[i] = GetProcAddress(hinst_mydll, DLL_FUNCTION_NAMES[i]);

  if(func_ptr[i] == NULL)
  {
    // error handling, most likely you have to terminate the program here
  }
}

If the loop was successful, the only problem we have now is calling the functions. The function pointer typedef from earlier isn't helpful, because each function will have its own signature. This can be solved by creating a struct with all the function types:

typedef struct
{
  int  (__stdcall* dll_add_ptr)(int, int);
  int  (__stdcall* dll_subtract_ptr)(int, int);
  void (__stdcall* dll_do_stuff_ptr)(something);
  ...
} functions_struct;

And finally, to connect these to the array from before, create a union:

typedef union
{
  functions_struct  by_type;
  func_ptr_t        func_ptr [DLL_FUNCTIONS_N];
} functions_union;

Now you can load all the functions from the DLL with the convenient loop, but call them through the by_type union member.

But of course, it is a bit burdensome to type out something like

functions.by_type.dll_add_ptr(1, 1); whenever you want to call a function.

As it turns out, this is the reason why I added the "ptr" postfix to the names: I wanted to keep them different from the actual function names. We can now smooth out the icky struct syntax and get the desired names, by using some macros:

#define dll_add (functions.by_type.dll_add_ptr)
#define dll_subtract (functions.by_type.dll_subtract_ptr)
#define dll_do_stuff (functions.by_type.dll_do_stuff_ptr)

And voilà, you can now use the function names, with the correct type and parameters, as if they were statically linked to your project:

int result = dll_add(1, 1);

Disclaimer: Strictly speaking, conversions between different function pointers are not defined by the C standard and not safe. So formally, what I'm doing here is undefined behavior. However, in the Windows world, function pointers are always of the same size no matter their type and the conversions between them are predictable on any version of Windows I've used.

Also, there might in theory be padding inserted in the union/struct, which would cause everything to fail. However, pointers happen to be of the same size as the alignment requirement in Windows. A static_assert to ensure that the struct/union has no padding might be in order still.

User · Answer

LoadLibrary does not do what you think it does  It loads the DLL into the memory of the current process  but it does not magically import functions defined in it  This wouldn t be possible  as function calls are resolved by the linker at compile time while LoadLibrary is called at runtime  remember that C   is a statically typed language    You need a separate WinAPI function to get the address of dynamically loaded functions  GetProcAddress   Example   include  lt windows h gt   include  lt iostream gt      Define a function pointer for our imported    function     This reads as  introduce the new type f funci as the type                     pointer to a function returning an int and                    taking no arguments        Make sure to use matching calling convention    cdecl    stdcall          with the exported function    stdcall is the convention used by the WinAPI     typedef int    stdcall  f funci      int main       HINSTANCE hGetProcIDDLL   LoadLibrary  C   Documents and Settings  User  Desktop  test dll       if   hGetProcIDDLL        std  cout  lt  lt   could not load the dynamic library   lt  lt  std  endl      return EXIT FAILURE            resolve function address here   f funci funci    f funci GetProcAddress hGetProcIDDLL   funci      if   funci        std  cout  lt  lt   could not locate the function   lt  lt  std  endl      return EXIT FAILURE         std  cout  lt  lt   funci   returned    lt  lt  funci    lt  lt  std  endl     return EXIT SUCCESS      Also  you should export your function from the DLL correctly  This can be done like this   int   declspec dllexport    stdcall funci                   As Lundin notes  it s good practice to free the handle to the library if you don t need them it longer  This will cause it to get unloaded if no other process still holds a handle to the same DLL

User · Answer

This is not exactly a hot topic  but I have a factory class that allows a dll to create an instance and return it as a DLL  It is what I came looking for but couldn t find exactly   It is called like   IHTTP Server  server   SN  SN Factory lt IHTTP Server gt   CreateObject    IHTTP Server  server2         SN  SN Factory lt IHTTP Server gt   CreateObject IHTTP Server special entry     where IHTTP Server is the pure virtual interface for a class created either in another DLL  or the same one   DEFINE INTERFACE is used to give a class id an interface  Place inside interface   An interface class looks like   class IMyInterface       DEFINE INTERFACE IMyInterface    public      virtual  IMyInterface            virtual void MyMethod1     0               The header file is like this   if  defined SN FACTORY H INCLUDED   define SN FACTORY H INCLUDED   pragma once   The libraries are listed in this macro definition  One line per library executable  It would be cool if we could call into another executable    define SN APPLY LIBRARIES L  A                                 L A  sn   sn dll                                            L A  http server lib   http server lib dll                  L A  http server        Then for each dll exe you define a macro and list its implementations  Def means that it is the default implementation for the interface  If it is not the default  you give a name for the interface used to identify it  Ie  special  and the name will be IHTTP Server special entry    define SN APPLY ENTRYPOINTS sn M                                            M IHTTP Handler  SNI  SNI HTTP Handler  sn  def                          M IHTTP Handler  SNI  SNI HTTP Handler  sn  special    define SN APPLY ENTRYPOINTS http server lib M                               M IHTTP Server  HTTP  server  server  http server lib  def    define SN APPLY ENTRYPOINTS http server M    With the libraries all setup  the header file uses the macro definitions to define the needful    define APPLY ENTRY A  N  L        SN APPLY ENTRYPOINTS   N A    define DEFINE INTERFACE I        public            static const long Id   SN  I   def entry        private   namespace SN        define DEFINE LIBRARY ENUM A  N  L            N   library    This creates an enum for the libraries       enum LibraryValues               SN APPLY LIBRARIES DEFINE LIBRARY ENUM              LastLibrary              define DEFINE ENTRY ENUM I  C  L  D            I     D   entry    This creates an enum for interface implementations       enum EntryValues               SN APPLY LIBRARIES APPLY ENTRY  DEFINE ENTRY ENUM          LastEntry             long CallEntryPoint long id  long interfaceId     This defines the factory class  Not much to it here       template  lt class I gt      class SN Factory           public          SN Factory                                static I  CreateObject long id   I  Id                         return  I   CallEntryPoint id  I  Id                        endif   SN FACTORY H INCLUDED   Then the CPP is    include  sn factory h    include  lt windows h gt    Create the external entry point  You can check that it exists using depends exe   extern  C          declspec dllexport  long entrypoint long id                 define CREATE OBJECT I  C  L  D                case SN  I     D   entry  return  int  new C             switch  id                        SN APPLY CURRENT LIBRARY APPLY ENTRY  CREATE OBJECT          case -1          default              return 0                      The macros set up all the data needed   namespace SN       bool loaded   false       char   libraryPathArray SN  LastLibrary        define DEFINE LIBRARY PATH A  N  L            libraryPathArray N   library    L       static void LoadLibraryPaths                 SN APPLY LIBRARIES DEFINE LIBRARY PATH                 typedef long  f entrypoint  long id        f entrypoint libraryFunctionArray LastLibrary - 1       void InitlibraryFunctionArray                 for  long j   0  j  lt  LastLibrary  j                          libraryFunctionArray j    0                      define DEFAULT LIBRARY ENTRY A  N  L                libraryFunctionArray N   library     amp entrypoint           SN APPLY CURRENT LIBRARY DEFAULT LIBRARY ENTRY                 enum SN  LibraryValues libraryForEntryPointArray SN  LastEntry        define DEFINE ENTRY POINT LIBRARY I  C  L  D                libraryForEntryPointArray I     D   entry    L   library      void LoadLibraryForEntryPointArray                 SN APPLY LIBRARIES APPLY ENTRY  DEFINE ENTRY POINT LIBRARY             enum SN  EntryValues defaultEntryArray SN  LastEntry            define DEFINE ENTRY DEFAULT I  C  L  D                defaultEntryArray I     D   entry    I   def entry       void LoadDefaultEntries                 SN APPLY LIBRARIES APPLY ENTRY  DEFINE ENTRY DEFAULT             void Initialize                 if   loaded                        loaded   true              LoadLibraryPaths                InitlibraryFunctionArray                LoadLibraryForEntryPointArray                LoadDefaultEntries                         long CallEntryPoint long id  long interfaceId                Initialize                assert defaultEntryArray id     interfaceId   Request to create an object for the wrong interface            enum SN  LibraryValues l   libraryForEntryPointArray id            f entrypoint f   libraryFunctionArray l           if   f                        HINSTANCE hGetProcIDDLL   LoadLibraryA libraryPathArray l                 if   hGetProcIDDLL                    return NULL                                resolve function address here             f    f entrypoint GetProcAddress hGetProcIDDLL   entrypoint                if   f                    return NULL                            libraryFunctionArray l    f                    return f id             Each library includes this  cpp  with a stub cpp for each library executable  Any specific compiled header stuff    include  sn pch h    Setup this library    define SN APPLY CURRENT LIBRARY L  A        L A  sn   sn dll     An include for the main cpp  I guess this cpp could be a  h  But there are different ways you could do this  This approach worked for me    include     inc sn factory cpp

[c++] Dynamically load a function from a DLL

Examples related to c++

Examples related to winapi

Examples related to dll