Methode in C++ DLL mit Autoit aufrufen?

**chip**

Hi,

ich habe eine DLL (gpgFuncDll.dll) mit folgendem Inhalt:

gpgFuncDLL.h

Spoiler anzeigen

Code

// gpgFuncDll.h


#ifdef GPGFUNCDLL_EXPORTS
#define GPGFUNCDLL_API __declspec(dllexport) 
#else
#define GPGFUNCDLL_API __declspec(dllimport) 
#endif




namespace gpgFunc
{
    // This class is exported from the gpgFuncDll.dll
    class MygpgFunc
    {
    public: 
        // Returns a + b
        static GPGFUNCDLL_API double Add(double a, double b); 


        // Returns a - b
        static GPGFUNCDLL_API double Subtract(double a, double b); 


        // Returns a * b
        static GPGFUNCDLL_API double Multiply(double a, double b); 


        // Returns a / b
        // Throws const std::invalid_argument& if b is 0
        static GPGFUNCDLL_API double Divide(double a, double b); 
    };
}

Alles anzeigen

gpgFuncDll.cpp

Spoiler anzeigen

C

// gpgFuncDll.cpp : Definiert die exportierten Funktionen für die DLL-Anwendung.
//


#include "stdafx.h"
#include "gpgFuncDll.h"




#include <stdexcept>


using namespace std;


namespace gpgFunc
{
    double MygpgFunc::Add(double a, double b)
    {
        return a + b;
    }


    double MygpgFunc::Subtract(double a, double b)
    {
        return a - b;
    }


    double MygpgFunc::Multiply(double a, double b)
    {
        return a * b;
    }


    double MygpgFunc::Divide(double a, double b)
    {
        if (b == 0)
        {
            throw invalid_argument("b cannot be zero!");
        }


        return a / b;
    }
}

Alles anzeigen

Mir ist aber nun nicht klar wie ich mit DLLCall z.b. die Methode "Add" aufrufen kann.

mfg

**alpines**

http://www.cplusplus.com/forum/beginner/63258/ ?

**chip**

Willst mir damit sagen, dass man mit Autoit nur Funktionen in Dlls aufrufen kann und kleine Klassen/Methoden?

**alpines**

Tut mir leid ich hab wohl nicht ganz aufgepasst. Schreib doch einfach eine .dll die die Funktionen so called das du sie mittels AutoIt ansprechen kannst.

AutoIt DllCall -> Handler.dll -> Funktion

**AspirinJunkie**

In der DLL müssen C-kompatible Schnittstellen definiert werden.
Du musst also für deine zu exportierenden Methoden einen C-Wrapper schreiben.

Beispiel:
Du hast eine Klasse "MyClass" mit den Methoden "Add" und "Subtract":

MyClass.h und MyClass.cpp

MyClass.h:

Code

namespace myNameSpace
{
	class MyClass
	{
	public: 
		double Add(double a, double b); 
		double Subtract(double a, double b); 
	};
}

MyClass.cpp:

Code

#include "MyClass.h"


namespace myNameSpace
{
	double MyClass::Add(double a, double b){
        return a + b;
    }

	double MyClass::Subtract(double a, double b){
        return a - b;
    }
}

Alles anzeigen

Um das ganze in C aufrufbar zu machen (und damit in AutoIt) musst du dir noch einen Wrapper schreiben:

CWrapper.h und CWrapper.cpp

CWrapper.h:

Code

extern "C" {
	__declspec(dllexport) void* MyClass_new();
	__declspec(dllexport) double MyClass_Add(void*, double, double);
	__declspec(dllexport) double MyClass_Subtract(void*, double, double);
}

CWrapper.cpp:

C

#include "CWrapper.h"
#include "MyClass.h"


using namespace myNameSpace;


extern "C"{

	// erzeugt ein neues Objekt der Klasse MyClass und gibt den Pointer zurück
	__declspec(dllexport) void* MyClass_new(){
		return static_cast<void*>(new MyClass());
	}

	// C-Wrapper für MyClass.Add()
	__declspec( dllexport ) double MyClass_Add(void* object, double a, double b){
		MyClass* instance = static_cast<MyClass*>(object);
		return instance->Add(a,b);
	}	


	// C-Wrapper für MyClass.Subtract()
	__declspec( dllexport ) double MyClass_Subtract(void* object, double a, double b){
		MyClass* instance = static_cast<MyClass*>(object);
		return instance->Subtract	(a,b);
	}	
}

Alles anzeigen

Jetzt muss das ganze noch in eine Dll kompiliert werden.
Hier mal als Beispiel für den Visual C++ Compiler als x64-Dll (Pfade anpassen!):

Dll kompilieren

Code

"C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\bin\amd64\cl.exe" /c MyClass.cpp


"C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\bin\amd64\cl.exe" /c CWrapper.cpp


"C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\bin\amd64\link.exe" /NXCOMPAT -dll /libpath:"C:\Program Files (x86)\Windows Kits\8.0\Lib\win8\um\x64" CWrapper.obj MyClass.obj

Man sollte nun als Ergebnis eine CWrapper.dll bekommen haben welche man mit AutoIt folgendermaßen handhabt:

erzeugte Dll in AutoIt nutzen

[autoit]

#AutoIt3Wrapper_UseX64=y

[/autoit] [autoit][/autoit] [autoit]

Global Const $h_DLL = DllOpen("CWrapper.dll")

[/autoit] [autoit][/autoit] [autoit]

; Objekt erzeugen:
Global $h_Object = DllCall($h_DLL, 'ptr:cdecl', 'MyClass_new')[0]

[/autoit] [autoit][/autoit] [autoit]

; Funktion MyClass.Add aufrufen:
Global $f_Sum = DllCall($h_DLL, 'double:cdecl', 'MyClass_Add', "ptr", $h_Object, "double", 5.0, "double", 6.0)[0]
ConsoleWrite(StringFormat("%20s:\t %f\n", "MyClass.Add", $f_Sum))

[/autoit] [autoit][/autoit] [autoit]

; Funktion MyClass.Subtract aufrufen:
Global $f_Diff = DllCall($h_DLL, 'double:cdecl', 'MyClass_Subtract', "ptr", $h_Object, "double", 5.0, "double", 6.0)[0]
ConsoleWrite(StringFormat("%20s:\t %f\n", "MyClass.Subtract", $f_Diff))

[/autoit] [autoit][/autoit] [autoit]

DllClose($h_DLL)

[/autoit]

Edit: Werden bei euch auch keine Unterstriche im Code angezeigt? - beim Kopieren des Codes sind sie zwar da - sichtbar sind sie hier aber leider nicht.

**chip**

Perfekt jetzt weiß ich bescheid. Danke AspirinJunkie.

**AspirinJunkie**

Wenn dir stdcall (man braucht dann kein :cdecl hinter den Rückgabetyp von DllCall zu schreiben) lieber ist dann müsste man den CWrapper und den AutoIt-Code folgendermaßen anpassen:

CWrapper.h und CWrapper.cpp

CWrapper.h:

Code

#define DLLOUT(Type) extern "C" __declspec(dllexport) Type __stdcall


DLLOUT(void*)	MyClass_new();
DLLOUT(double)	MyClass_Add(void*, double, double);
DLLOUT(double)	MyClass_Subtract(void*, double, double);

CWrapper.cpp:

C

#include "CWrapper.h"
#include "MyClass.h"


using namespace myNameSpace;


// erzeugt ein neues Objekt der Klasse MyClass und gibt den Pointer zurück
DLLOUT(void*) MyClass_new(){
	return static_cast<void*>(new MyClass());
}


// C-Wrapper für MyClass.Add()
DLLOUT(double) MyClass_Add(void* object, double a, double b){
	MyClass* instance = static_cast<MyClass*>(object);
	return instance->Add(a,b);
}	


// C-Wrapper für MyClass.Subtract()
DLLOUT(double) MyClass_Subtract(void* object, double a, double b){
	MyClass* instance = static_cast<MyClass*>(object);
	return instance->Subtract	(a,b);
}

Alles anzeigen

erzeugte Dll in AutoIt nutzen

[autoit]

#AutoIt3Wrapper_UseX64=y

[/autoit] [autoit][/autoit] [autoit]

Global Const $h_DLL = DllOpen("CWrapper.dll")

[/autoit] [autoit][/autoit] [autoit]

; Objekt erzeugen:
Global $h_Object = DllCall($h_DLL, 'ptr', 'MyClass_new')[0]

[/autoit] [autoit][/autoit] [autoit]

; Funktion MyClass.Add aufrufen:
Global $f_Sum = DllCall($h_DLL, 'double', 'MyClass_Add', "ptr", $h_Object, "double", 5.0, "double", 6.0)[0]
ConsoleWrite(StringFormat("%20s:\t %f\n", "MyClass.Add", $f_Sum))

[/autoit] [autoit][/autoit] [autoit]

; Funktion MyClass.Subtract aufrufen:
Global $f_Diff = DllCall($h_DLL, 'double', 'MyClass_Subtract', "ptr", $h_Object, "double", 5.0, "double", 6.0)[0]
ConsoleWrite(StringFormat("%20s:\t %f\n", "MyClass.Subtract", $f_Diff))

[/autoit] [autoit][/autoit] [autoit]

DllClose($h_DLL)

[/autoit]