C_Wrapper

Hallo Zusammen,

ich habe folgende Problem:
Ich habe es einen DLL von einen C++ Code erstellt.
In dieses DLL Code habe einen C_Wrapper geschrieben, damit ich diesem DLL in LabVIEW inportieren kann.

Bis hier ist alles Okay.
Diesem Code kann ich mit Visual Studio und LabVIEW in debug Modus durchlaufen.
Anbei einen Codeausschnitt "C_Wrapper" von einen Dummy Projekt:

Header File:

#pragma once
#ifdef __cplusplus
#endif
....
    extern "C"__declspec(dllexport) void* createWrapper(double a, double b);
    extern "C"__declspec(dllexport) void destoryWrapper(void *instance);
    extern "C"__declspec(dllexport) double Add(void *instance, double a, double b);
.....
#ifdef __cplusplus
#endif

Source File:

#include "stdafx.h"
#include "MyClass.h"
#include "C_DllWrapper.h"

extern "C"__declspec(dllexport) void* createWrapper(double a, double b)
{
	return new MyClass(a, b);
}

extern "C"__declspec(dllexport) void destoryWrapper(void *instance)
{
	MyClass *myClass = static_cast<MyClass*>(instance);
	delete myClass;
}
extern "C"__declspec(dllexport) double Add(void *instance, double a, double b)
{
	MyClass *myClass = static_cast<MyClass*>(instance);
	return myClass->Add(a, b);
}

MyClass ist ein class in diesem DummyProjekt, die sieht so aus:

class MyClass
{
public:
	MyClass(double, double);
	~MyClass();
	double Add(double,double );
private:
	double m_a, m_b;
};

Mein Problem ist:Wie kann ich meinen Funktion "

extern "C"__declspec(dllexport) double Add(void *instance, double a, double b);

"
über der Point Objekt "

void *instance

" referenzieren?

In diesesem dummy Projekt spielt keine Rolle, ob es diesem Objekt"

void *instance

" NULL oder nicht ist.

Wenn ich diesesem DummyObjekt auf C++ seite testen möchte, wäre ich umgegangen:
TestProgramm "in c++" wird dann so aussehen:

....
int main()
{
void *ref = create(1,2);
Add(ref,5,7);
....
}

Ich stehe auf dem Schlauch:
Wie soll ich das auf C++ Seite tun?
bzw: Soll ich das auf C++ seite tun?
Die Idee dahinter ist:
Der User "Auf LabVIEW" seite muss er nichts konfigurieren.

Danke und Sorry für so eine Lange Beitrag.

DarkShadow44

Sorry ich verstehe absolut nicht was du wissen willst.
Du hast doch schon alles was du für einen Wrapper brauchst?

DarkShadow44 schrieb:

Sorry ich verstehe absolut nicht was du wissen willst.
Du hast doch schon alles was du für einen Wrapper brauchst?

Was ich wissen wollte ist:
Wenn ich diese Funktion

extern "C"__declspec(dllexport) double Add(void *instance, double a, double b);

mittels LabVIEW aufrufe, ist dieses Objeckt "instance" gleich NULL.

Ich muss so vorgehen:

das Objekt kreieren in dem ich dieses Methode aufrufe:

extern "C"__declspec(dllexport) void* createWrapper(double a, double b)

. Ich möchte dieses creaierte Objeckt weiter benutzen, aber wie...?

"Problem: die Gültigkeit ist nur innerhalt dieses Funktion"
und wenn ich eine andere Funktion aufrufe, dann ist das Objeckt "void *instance" gleich NULL

Dieses Wrapper bzw. der DLL File wird in Labview importiert und deswegen brauche ich eine Reference von "void * instance".

IstStand(Auf LabVIEW): Objeckt instance ist stets NULL

DarkShadow44

Entweder du legst das Objekt in einer Variable von Labview ab und lässt dir das übergeben (keine Ahnung von dem Programm) oder du legst das Objekt in einer statischen Variable in der DLL ab.

DarkShadow44 schrieb:

Entweder du legst das Objekt in einer Variable von Labview ab und lässt dir das übergeben (keine Ahnung von dem Programm) oder du legst das Objekt in einer statischen Variable in der DLL ab.

Wenn ich ganz doof Frage: Wie lege ich den das Objekt in einer statischen Variable in der DLL ab? Sorry

DarkShadow44

MyClass* staticMyClassObject;

extern "C"__declspec(dllexport) void createWrapper(double a, double b) 
{ 
    staticMyClassObject = new MyClass(a, b); 
} 

extern "C"__declspec(dllexport) void destoryWrapper() 
{ 
    delete staticMyClassObject; 
}

extern "C"__declspec(dllexport) double Add(double a, double b) 
{ 
    return staticMyClassObject->Add(a, b); 
}

Solltest du aber doch schon kennen?

eigentlich beide Varianten (V1 und V2) bringen zum Ziel :

V1: "Makus_gast":
cpp:

extern "C"__declspec (dllexport) void* createWrapper(double a, double b)
{
	return new MyClass(a,b); 
}

extern "C"__declspec (dllexport) void destoryWrapper(void *instance)
{
	delete static_cast<MyClass*>(instance);
}

extern "C"__declspec (dllexport) double Add(void *instance, double a, double b)
{
	MyClass *myClass = static_cast<MyClass*>(instance);
	return myClass->Add(a, b);
}

V2: DarkShadow44
cpp:

MyClass* staticMyClassObject;

extern "C"__declspec(dllexport) void createWrapper(double a, double b)
{
    staticMyClassObject = new MyClass(a, b);
}

extern "C"__declspec(dllexport) void destoryWrapper()
{
    delete staticMyClassObject;
}

extern "C"__declspec(dllexport) double Add(double a, double b)
{
    return staticMyClassObject->Add(a, b);
}

@ Markus_gast:

Das Objekt kannst du auch jedes mal erzeugen in dem du so machst z.B:

--> für V1:

extern "C"__declspec (dllexport) double Add(void *instance, double a, double b)
{
	MyClass *myClass = static_cast<MyClass*>(createWrapper(a,b));
	return myClass->Add(a, b);
}

--> für V2:

extern "C"__declspec(dllexport) double Add(double a, double b)
{
	createWrapper(a,b);
    return staticMyClassObject->Add(a, b);
}

--> Die Frage ist: Welche der Varianten ist zu empfehlen ?