could not load c++ dll in python

I am trying to use a C++ .dll in Python, but I can't even load it. I am trying the following python code to load it:

from ctypes
import cdll
mydll = cdll.LoadLibrary('SORT_DLL.dll')

But when I try to run this I get:

D:\...\src\SORT_DLL\Debug>UseDll.py
Traceback (most recent call last):
File "D:\...\src\SORT_DLL\Debug\UseDll.py", line 2, in
<module>
   mydll = cdll.LoadLibrary('SORT_DLL.dll')
   File "C:\Python27\lib\ctypes\__init__.py", line 443, in LoadLibrary
   return self._dlltype(name)
   File "C:\Python27\lib\ctypes\__init__.py", line 365, in __init__
   self._handle = _dlopen(self._name, mode)
   WindowsError: [Error 193] %1 ist keine zulõssige Win32-Anwendung

Suggestion : 2

04/12/2022

When you create a DLL, you can optionally specify an entry point function. The entry point function is called when processes or threads attach themselves to the DLL or detached themselves from the DLL. You can use the entry point function to initialize data structures or to destroy data structures as required by the DLL. Additionally, if the application is multithreaded, you can use thread local storage (TLS) to allocate memory that is private to each thread in the entry point function. The following code is an example of the DLL entry point function.

BOOL APIENTRY DllMain(
   HANDLE hModule, // Handle to DLL module
   DWORD ul_reason_for_call, // Reason for calling function
   LPVOID lpReserved) // Reserved
{
   switch (ul_reason_for_call) {
      case DLL_PROCESS_ATTACHED: // A process is loading the DLL.
         break;
      case DLL_THREAD_ATTACHED: // A process is creating a new thread.
         break;
      case DLL_THREAD_DETACH: // A thread exits normally.
         break;
      case DLL_PROCESS_DETACH: // A process unloads the DLL.
         break;
   }
   return TRUE;
}

You can also use a module definition file to declare exported DLL functions. When you use a module definition file, you do not have to add the function keyword to the exported DLL functions. In the module definition file, you declare the LIBRARY statement and the EXPORTS statement for the DLL. The following code is an example of a definition file.

// SampleDLL.def
//
LIBRARY "sampleDLL"
EXPORTS HelloWorld

The following code is an example of a DLL that was created in Visual C++ by using the Win32 Dynamic-Link Library project type.

// SampleDLL.cpp
//

#include "stdafx.h"

#define EXPORTING_DLL#include "sampleDLL.h"

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

void HelloWorld() {
   MessageBox(NULL, TEXT("Hello World"), TEXT("In a DLL"), MB_OK);
}

// File: SampleDLL.h
//
#ifndef INDLL_H
#define INDLL_H
#ifdef EXPORTING_DLL
extern __declspec(dllexport) void HelloWorld();
#else
extern __declspec(dllimport) void HelloWorld();
#endif

#endif

In run-time dynamic linking, you use code that is similar to the following code to call the SampleDLL.dll exported DLL function.

...
typedef VOID( * DLLPROC)(LPTSTR);
...
HINSTANCE hinstDLL;
DLLPROC HelloWorld;
BOOL fFreeDLL;

hinstDLL = LoadLibrary("sampleDLL.dll");
if (hinstDLL != NULL) {
   HelloWorld = (DLLPROC) GetProcAddress(hinstDLL, "HelloWorld");
   if (HelloWorld != NULL)
      (HelloWorld);
   fFreeDLL = FreeLibrary(hinstDLL);
}
...

Suggestion : 3

It's very odd to me that python doesn't search sys.path for dll dependencies. The paths that it needed to search were also on os.environ['PATH'], but again it didn't search them. I'm not sure if there is a nicer way to do this. I would like to hear about it if there is.,I followed the tutorial here following doqtor's comment, and found that the problem was python not loading several dlls that were runtime dependencies of PythonBindings.pyd.,Created Blender Obj but in OpenGL it loses it's texture?,Boost Python No to_python converter found for std::string

This was fixed by adding

import sys
import os
   [os.add_dll_directory(dir) for dir in sys.path
      if os.path.isdir(dir)]

Suggestion : 4

In Microsoft Visual C++ 6.0, you can create a DLL by selecting either the Win32 Dynamic-Link Library project type or the MFC AppWizard (dll) project type.,DLL files don't get loaded into the RAM together with the main program; they don't occupy space unless required. When a DLL file is needed, it is loaded and run. For example, as long as a user of Microsoft Word is editing a document, the printer DLL file is not required in RAM. If the user decides to print the document, then the Word application causes the printer DLL file to be loaded and run.,USER32.DLL - Contains numerous user interface functions. Involved in the creation of program windows and their interactions with each other.,By using Dependency Walker, you can document all the DLLs that a program uses. It may help prevent and correct DLL problems that may occur in the future. Dependency Walker is located in the following directory when you install Microsoft Visual Studio 6.0:

Additionally, if the application is multithreaded, you can use thread local storage (TLS) to allocate memory that is private to each thread in the entry point function. The following code is an example of the DLL entry point function.

BOOL APIENTRY DllMain(
      HANDLE hModule, // Handle to DLL module DWORD ul_reason_for_call, LPVOID lpReserved )  // Reserved
      {
         switch (ul_reason_for_call) {
            case DLL_PROCESS_ATTACHED:
               // A process is loading the DLL.
               break;
            case DLL_THREAD_ATTACHED:
               // A process is creating a new thread.
               break;
            case DLL_THREAD_DETACH:
               // A thread exits normally.
               break;
            case DLL_PROCESS_DETACH:
               // A process unloads the DLL.
               break;
         }
         return TRUE;
      }

To use a function keyword, you must declare each function that you want to export with the following keyword:

 __declspec(dllexport)

To use exported DLL functions in the application, you must declare each function that you want to import with the following keyword:

 __declspec(dllimport)

The following code is an example of a DLL that was created in Visual C++ by using the Win32 Dynamic-Link Library project type.

// SampleDLL.cpp

#include "stdafx.h"

#define EXPORTING_DLL#include "sampleDLL.h"

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

void HelloWorld() {
   MessageBox(NULL, TEXT("Hello World"),
      TEXT("In a DLL"), MB_OK);
}

// SampleDLL.cpp

#include "stdafx.h"
#define EXPORTING_DLL
#include "sampleDLL.h"

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

void HelloWorld()
{
   MessageBox( NULL, TEXT("Hello World"), 
   TEXT("In a DLL"), MB_OK);
}

// File: SampleDLL.h
//
#ifndef INDLL_H
#define INDLL_H

#ifdef EXPORTING_DLL
extern __declspec(dllexport) void HelloWorld();
#else
extern __declspec(dllimport) void HelloWorld();
#endif

#endif

Suggestion : 5

Unix and Windows use completely different paradigms for run-time loading of code. Before you try to build a module that can be dynamically loaded, be aware of how your system works.,In Windows, a dynamic-link library (.dll) file has no dangling references. Instead, an access to functions or data goes through a lookup table. So the DLL code does not have to be fixed up at runtime to refer to the program’s memory; instead, the code already uses the DLL’s lookup table, and the lookup table is modified at runtime to point to the functions and data.,Module authors are encouraged to use the distutils approach for building extension modules, instead of the one described in this section. You will still need the C compiler that was used to build Python; typically Microsoft Visual C++.,Suppose you are building two dynamic-load modules, B and C, which should share another block of code A. On Unix, you would not pass A.a to the linker for B.so and C.so; that would cause it to be included twice, so that B and C would each have their own copy. In Windows, building A.dll will also build A.lib. You do pass A.lib to the linker for B and C. A.lib does not contain code; it just contains information which will be used at runtime to access A’s code.

cl / LD / I / python / include spam.c.. / libs / pythonXY.lib
cl / LD / I / python / include ni.c spam.lib.. / libs / pythonXY.lib