dlls für berechnungen

yxyx: Ich würd in C++ erstmal mit einfachen Dingen weitermachen, wenn du jetzt erst angefangen hast.

Du könntest ein Konsolen Tic Tac Toe machen.

Hab auch mal eins gemacht. Du kannst den Stil ja kopieren.

hoi ich habs auch direkt mal ausprobiert, weil es mich schon ne ganze zeit interessiert wie die dlls so aufgebaut sind aber ein paar fragen hätte ich noch.
das ist ja der code:

extern "C" int __declspec(dllexport) myfunc (int x)
{
return (x*2);
}

so, was bedeutet denn jetzt genau das:

extern "C" int __declspec(dllexport) myfunc (int x)

wieso extern"C"?? wieso int__declspec(dllexport)?? das letzte ist klar.

Und was ist wenn ich in eine Dll mehr Fubktionen packen will sieht das dann so aus?

extern "C" int __declspec(dllexport) myfunc1 (int x)
{
return (x*2);
}


extern "C" int __declspec(dllexport) myfunc2 (int x)
{
return (x*3);
}


extern "C" int __declspec(dllexport) myfunc3 (int x)
{
return (x*4);
}

und zum teil werden ja auch Icons in eine dll gepackt wie funktioniert das?

mfg Darter

Zitat von clezZ

Hab auch mal eins gemacht. Du kannst den Stil ja kopieren.

nicht schlecht aber hast du da auch mal die Source daz?

Also wegen Bildern könnte ich mir vorstellen, einfach den Binarystring von dem Build als Returnwert in der dll unter einer Funktion speichen und einfach mit AutoIt mit DllCall aufrufen, in $aRet[0] liegt dann der Binarystring und diesen dann mit FileWrite im Binärmodus eintragen und speichern...

extern "C" bedeutet, dass die dll Funktion im C Stil erstellt wird (zumindest glaub ich das)

Und den Quellcode zum Tic Tac Toe gibts NOCH nicht, damit yxyx ein bissl nachdenken muss

Zitat von clezZ

extern "C" bedeutet, dass die dll Funktion im C Stil erstellt wird (zumindest glaub ich das)

Und den Quellcode zum Tic Tac Toe gibts NOCH nicht, damit yxyx ein bissl nachdenken muss

Aber mein bsp mit mehr funktionen in einer dll ist schon richtig so oder und du könntest mir wenn du willst du source ja als pm schicken

Das Beispiel ist schon richtig.

Den Quellcode geb ich her, wenn der andere wenigstens versucht hat ein Tic Tac Toe zu machen. Sonst hat er die Lösung ja schon auf der Hand, und schreibt alles ab.

sowas geht aber nicht Kann man denn keine array returnen?

extern "C" int __declspec(dllexport) myfunc1 (int x)
{
return (x*2);
}
extern "C" int __declspec(dllexport) myfunc2 (int x)
{
int array[3];
array[0] = x*1;
array[1] = x*2;
array[2] = x*3;
return array;
}

Arrays gehen schon, ich kann jedoch nur eine Lazarus-Dll (FreePascal) als Beispiel anbieten:

library ArrayDll;


Type
TArray = Array[0..10] of DWord;
PArray = ^TArray;


Function ReturnArray(): PArray; stdcall;
Var aRet : PArray;
    iLoop : DWord;
Begin
     New(aRet);
     For iLoop:=0 To 9 Do aRet^[iLoop]:=iLoop;
     ReturnArray:=aRet;
End;


exports ReturnArray;


begin
end.

$Dll = DllOpen("Arraydll.dll")
If @error Then Exit

$aRet = DllCall($Dll, "ptr", "ReturnArray")
If @error Then Exit

$tStruct = DllStructCreate("DWord[10]", $aRet[0])
For $i = 1 To 10
ConsoleWrite($i & " " & DllStructGetData($tStruct, 1, $i) & @LF)
Next
DllClose($Dll)

Das geht sicher auch mit C++

wow tut mir leid aber ich verste da nur bahnhof ich war froh, dass ich ne einfache dll erstellen konnte und diese callen aber vllt kannst du mir ja deinen code etwas erläutern.

Im Prinzip gibt man nicht das Array als solches zurück, sondern nur seinen Pointer...

in meinem Beispiel ist PArray der Pointer zu TArray.
genauer kann ich das leider auch nicht beschreiben

Edit:
Vielleicht hilft es, wenn du dir das so vorstellst:

Type
TArray = Array[0..10] of DWord;
PArray = ^TArray;

=

$TArray = DllStructCreate("DWord[10]")
$PArray = DllStructGetPtr($TArray)

ich habs mal so probiert:

die dll:

extern "C" int* __declspec(dllexport) myfunc2 (int x)
{
int array[3];
int* zeiger;
int i;
array[0] = 111;
array[1] = 222;
array[2] = 333;
zeiger=array[0];


return zeiger;
}

und ein script dazu:

$Dll = DllOpen("Dll_Test.dll")
Myerrorcheck()
$aRet = DllCall($Dll, "ptr", "myfunc2")
Myerrorcheck()
$tStruct = DllStructCreate("int", $aRet[0])
Myerrorcheck()
$Structdata = DllStructGetData($tStruct, 1, 1)
Myerrorcheck()
MsgBox(0,"",$Structdata)

Func Myerrorcheck()
If @error Then
MsgBox(0,"Fehler",@error)
Exit
EndIf
EndFunc

ich hab kp ob das auch nur ansatzweise richig ist aber im prinzip zeigt mein pointer auf das erste element meines Arrays so müsste das doch richitg sein oder?

Ich hab mir jetzt nur mal den C++ Code angeschaut, und da sind einige Fehler drin:

extern "C" int* __declspec(dllexport) myfunc2 (int x)
{
int array[3];
int* zeiger=0; //Pointer immer auf Null setzen vor dem Gebrauch
int i;
array[0] = 111;
array[1] = 222;
array[2] = 333;
*zeiger=&array[0]; //Der Zeiger zeigt auf die Speicheradresse des Arrays


return zeiger; //Hier wird dann die Speicheradresse zurück gegeben.
}

An alle, die sich mit Pointern nicht so auskennen: Seit bloß vorsichtig (Bin mir nichtma sicher, ob ich alles richtig gemacht hab.)

Hi,

hab mich mal durchgelesen und wollte auch mal meinen Senf dazu geben.

Wenn ich die Funktion "myfunc2" in C++ folgendermaßen verwende:

#include <iostream>


using namespace std;


int* Test(void);


int main()
{
    int* T = Test();
    cout << T << endl;


    cout << *T << endl;


    return 0;
}


int* Test(void)
{
    int Array[3];
    int* zeiger = 0;


    Array[0] = 111;
    Array[1] = 222;
    Array[2] = 333;


    aPTR = &Array[0];
    return aPTR;
}

Wird auf der Konsole folgendes ausgegeben:
"0x22ff30", sowie der Wert "2293472", komisch sollte eigtl. "111" sein.

Warum das passiert ist im Endeffekt ganz einfach, da in C++ bzw., ich glaub in jeder Programmiersprache, ein Array nichts anderes als ein Pointer/Zeiger
ist.
Wenn man in einer Funktion eine Variable deklariert, wird nach dem Funktionsaufruf, diese Speicherstelle (Adresse) wieder vom Wert der Variable "bereinigt",
die Speicheradresse bleibt vorhanden, nicht aber der Wert, dem man dieser zugewiesen hat.
Um dieses Problem gibt es das Schlüsselwort "new".
Mit diesem fordern wir Speicher an, der erst wieder freigegeben wird, wenn wir mit "delete" dies sagen.

"new" benötigt noch einen Datentyp, sowie muss es wissen ob mehrere verlangt werden:
"delete" benötigt die Speicheradresse, welche wiederfreigegeben werden soll.

int* p = new int;
int* pt = new int[3];


delete p;
delete[] pt;

Mal als Beispiel:

int* ArrayTest(int x)
{
   int* aRet = new int[2];
   aRet[0] = x;
   aRet[1] = x * 2;
   return aRet;
}

Verwenden wir diese "Funktion" mal als Beispiel:

#include <iostream>


int main()
{
   int* T = ArrayTest(2);


   std::cout << T << std::endl;
   std::cout << T[0] << std::endl;


   return 0;
}

#include <iostream>


int main()
{
   int* T = ArrayTest(2);


   std::cout << T << std::endl;
   std::cout << *T << std::endl;


   return 0;
}

#include <iostream>


int main()
{
    int* T = ArrayTest(2);
    std::cout << T << std::endl;
    std::cout << *T << std::endl;


    *T++; //*T += 1; ginge auch


    std::cout << T << std::endl;
    std::cout << *T << std::endl;


    delete[] T;
    return 0;
}

Der somit berichtigte Anfangscode lautet nun:

#include <iostream>


int* ArrayTest(void);


int main()
{
    int* T = ArrayTest();
    std::cout << T << std::endl;


    std::cout << *T << std::endl;


    delete[] T;
    return 0;
}


int* ArrayTest(void)
{
    int* Array = new int[3];
    int* aPTR = 0;


    Array[0] = 111;
    Array[1] = 222;
    Array[2] = 333;


    aPTR = &Array[0];
    return aPTR;
}

Es ist möglich in C++ ein Array zurückzugeben, der Speicher dazu muss allerdings mit "new/new[x]" angefordert werden, dieser muss dann allerdings mit "delete/delete[]" freigegeben werden.
Möchte man nur einen "int" anfordern schreibt man nur "new int" und dann "delete xyz", möchte man mehrere "int"´s anfordern, dann
"new int[x]" und "delete[] xyz", wobei "xyz", die Speicheradresse ist, mit der der Speicher angefordert wurde.
Statt "int" geht natürlich auch jeder andere Datentyp.

Hoffe, dass ich alles klar und verständlich erklärt habe.

LG
Ealendil

PS: Ist zwar ein AutoIt-Forum, aber ich dachte vlt. braucht das mal ein AutoIt-ler für C++.