Objektzugriff und DLL's

coldAsIce

Hallo,

ich bin ziemlich neu in der Materie C/C++ und
hab mal eine Frage bezügl. folgenden Problems:

Ich habe eine Klasse Matrix definiert und implementiert,
die u.A. die Methoden

__declspec (dllexport) Matrix* Matrix::add(Matrix& summand){...}

und

__declspec (dllexport) Matrix::Matrix(int zeilen, int spalten)

enthält.

Also einen Konstruktor und eine Methode zum Addieren zweier Matritzen,
wobei - und das ist so ein bisschen mein Problem - die Addition auf ein
Matrix-Objekt in der Form

Matrix* A = new Matrix(4,4);
...
Matrix* B = new Matrix(4,4);
...

Matrix* Summe = A->add(*B);

angewendet werden soll.

Der ganze Quatsch steht also in einer DLL drinne.
Wenn ich jetzt mit VC++ das Matrix-DLL-Projekt in ein anderes Anwendungs-
projekt importiere und die Abhängigkeiten einstelle, dann funktioniert
die Addition so wie oben beschrieben auch im Anwendungsprojekt.

Mein Problem ist aber, wenn ich das ganze dynamisch machen will,
also mit loadlibrary nur die DLL lade, dann weiß ich nicht so genau,
wie ich das umsetzen soll.
Ich habe dann da z.B. eine auf add(Matrix& gelinkte Funktion addMatrix
(Matrix& B), kann das aber ja nicht ausführen weil add(...) an ein Matrix - Objekt gebunden ist, welches die DLL nicht kennt.

Die einfachste Möglichkeit wäre natürlich die Addition z.B. so umzuschreiben,
dass beide Matrizen an die DLL-Funktion übergeben werden.

Genau das wil ich aber nicht, da es ja statisch auch funktioniert (wenn VC
es übernimmt).
Ich hoffe ihr versteht mein Problem und könnt mir da weiterhelfen,
ist bestimmt irgend was ganz dummes.

Viele Grüße,

Cool

Ringding

Ich weiß nicht, wie das gehen sollte, wenn du nicht einen Haufen Wrapperfunktionen schreiben willst. Du könntest die DLL aber auf delay-load stellen, wenn dir das was nützt.

Christoph

coldAsIce schrieb:

Ich hoffe ihr versteht mein Problem und könnt mir da weiterhelfen,
ist bestimmt irgend was ganz dummes.

Dein Problem ist, dass Klassen und DLLs sich nicht gut vertragen. DLLs sollten unabhängig von der Programmiersprache benutzbar sein. Das ist bei deiner DLL aber überhaupt nicht der Fall, du könntest also genausogut eine statische LIB benutzen.

Mit LoadLibrary/GetProcAddress kannst du Member-Funktionen nur sehr umständlich laden.
Du musst mit dem Dependency Walker die richtigen Namen der Funktionen herausfinden und mit reinterpret_cast konvertieren.

coldAsIce

und vielen Dank schon mal für die schnellen Antworten.

Ich kann mir schon vorstellen, dass das was ich vorhabe
sehr umständlich ist, aber ich bin noch dabei mich mit
c++ vertraut zu machen.

Wie funktioniert denn das was cd9000 da gesagt hat mit diesem
reinterpret_cast?

Kann mir das vielleicht mal jemand anhand von einem Beispiel erklären
oder kann mir jemand sagen wo es code gibt, der zeigt, wie man Memberfunktionen
und den this* - Zeiger mit DLL's handeln kann.

Das normale Matrix* C = B->addMatrix(*A) funktioniert ja natürlich nicht,
weil die von Klasse Matrix definierte Funktion ja add(Matrix& heißt,
die von der DLL exportierte und auf add(...) gelinkte Funktion aber den Namen addMatrix(...) hat.

Vielen Dank schonmal,
Cool

coldAsIce

ich hab das mit getProcAdress etc. auch alles gemacht und auch
die richtigen Funktionsnamen mit dem Dependency Walker herausgesucht,
mein Problem ist dass ich nicht weiß wie ich von außen auf die Memberfunktionen
zugreifen soll.

Viele Grüße

C++ Forumbot

Dieser Thread wurde von Moderator/in Gerard aus dem Forum C++ in das Forum WinAPI verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

D*niel *chumann

Ich glaub, du musst dir eine Funktion schreiben, z.B. MYCLASS* CreateMyClass();, die dir einen Zeiger auf eine erstellte Instanz der Klasse zurückgibt. Die lädst du dann mit GetProcAddress und bekommst beim Aufruf eine Instanz der Klasse. Am besten gibst du der Dll dann auch noch eine void FreeMyClass(MYCLASS*); -Funktion um die Instanz wieder zu löschen.

coldAsIce

Hallo,

eine Funktion createMyClass hab ich,
es ist ja der Konstruktor Matrix(int zeilen, int spalten)!
Dieser wird beim Aufruf der DLL gelinkt als
Matrix(int, int) und gibt wie erwartet einen Zeiger auf
ein Matrix-Objekt zurück.
Das ist ja logisch.

Mein Problem ist wirklich, dass ich nicht weiß,
wie ich der DLL klarmachen soll, das der Funktionsaufruf von
addMatrix(Matrix& auf ein Matrix-Objekt ausgeführt werden muß,
weil addMatrix(...) einen Funktionszeiger auf die Memberfunktion add(...)
der Klasse Matrix zurückgibt (die ja in der DLL gekapselt ist).

Irre ich mich oder ist dies vielleicht gar nicht möglich, ist es
evtl. nur möglich die Methode add als add(Matrix& A, Matrix& zu implementieren (und dementsprechend die Methoden Matrix::getZeilen(void)
nur als static Matrix::getZeilen(*Matrix A) und Matrix::print(void) als
static Matrix::print(*Matrix A)) ?

Viele Grüße

D*niel *chumann

Du inkludierst die Header-Datei deiner Klasse in deinem Anwendungsprojekt. Dort rufst du GetProcAddress mit "CreateMyClass" auf und erhältst so einen Zeiger auf die Funktion, die dir eine Instanz der Klasse zurückgibt. Mit der Instanz kannst du dann das machen, was du schon als allererstes geschrieben hast:

Matrix* A = CreateMyClass(4,4); 
//... 
Matrix* B = CreateMyClass(4,4); 
//... 

Matrix* Summe = A->add(*B);

CreateMyClass ist in der Dll und sieht z.B. so aus:

Matrix* CreateMyClass(int a, int b){
    return new Matrix(a, b);
}

Müsste doch so gehen, oder?

coldAsIce

Also so ähnlich hab ichs ja probiert,

das ist genau mein Problem, dass es so nicht geht.

Viele Grüße

Ringding

Das geht aber nur, wenn jede Methode virtuell ist.

coldAsIce

Was bedeuted virtuell?

Viele Grüße

Christoph

coldAsIce schrieb:

Was bedeuted virtuell?

Wenn "virtual" vor der Methode steht, ist sie virtuell.
Das bedeutet, dass du über Basisklassenzeiger Methoden einer abgeleiteten Klasse aufrufen kannst. Bsp.:

class A
{
  public:
    virtual void foo() { cout << "a"; };
};
class B : public A
{
  public:
    void foo() { cout << "b"; }; // virtual muss man hier nicht wiederholen
}

void bar()
{
  B b;
  A* a = &b;
  a->foo(); // gibt "b" aus, obwohl es ein A* ist.
}

p.s.: Was virtual bedeutet, solltest du IMHO aber wissen, bevor du dich mit der WinAPI befasst. Das ist C++-Grundwissen.

coldAsIce

Na ja,

müsste ich vielleicht wissen.
Komme aber von Java und da gibt es
dieses Schlüsselwort nicht.
Ich will mich ja auch nur etwas mit
den verschiedenen Möglichkeiten, die c++ bietet,
vertraut machen (wegen Diplomarbeit), darum auch das ganze als
DLL mit dynamischer Bindung.
Ich sehe trotzdem immer noch nicht den Vorteil bei
meinem Beispiel mit diesem Schlüsselwort zu arbeiten, da
ich überhaupt nichts vererbe.

Ich denke fast, es geht nur wenn ich die Methoden so umschreibe,
dass ich Zeiger auf beide Matrixobjekte übergebe.
Ist zwar kein Problem, aber es muß auch anders gehen.
Wie gesagt, wenn ich das DLL-Projekt mit VC in das zugreifende
Projekt lade, geht es ja auch.
Ich verwende dann allerdings nicht loadlibrary.

Falls doch noch jemandem was einfällt wäre ich froh, wenn er
hier posten würde.

Viele Grüße