C++ globale Referenz in dll nicht möglich?

T_55

Lieutenant
Registriert
Feb. 2013
Beiträge
638
Hallo,

bei einem Konsoleprogramm das eine dll einbindet (beides c++ siehe unten) übergebe ich ganz gerne die Variablen im Struct verpackt als Referenz an die dll.
Nun ist mir die Idee gekommen was in der dll-Funktion lokal so schön geht sollte doch auch irgendwie global gehen. Warum könnte man die Structreferenz nicht einfach zu beginnt der Programms einmalig an die dll übergeben, so dass es global und so die ganze Lebensdauer des Programms zur Verfügung steht. Der Adresse des Structs sollte doch eh immer gleich bleiben. Sparen würde man so das permanente Übergeben des Structs in Folgefunktionen die alle mit den Daten arbeiten wollen. Das Ganze habe ich mal probiert aber es scheint nicht zu gehen oder ich hab mal wieder irgendwo ein Fehler gemacht.

Da das Erstellen der Referenz in der dll eine Quelle will, habe ich als Trick zuerst eine alternative Variable (des Structs) zugewiesen und erst bei Aufruf der ersten Funktion, wird dann die eigentliche Referenz auf das Struct des Konsoleprogramms abgeändert. So die Idee, steht in der dll die Referenz auf das Struct im Konsoleprogramm global zur Verfügung.

Bei der ersten Funktion stimmt der Rückgabewert noch mit dem Original überein aber ab der Addition in der zweiten Funktion sieht man, dass sich der Originalwert nicht verändert obwohl die Referenz in der dll manipuliert wird. Irgendwas scheint hier nicht zu funktionieren. Das Ziel wäre das Struct der Konsoleanwendung in der dll per globale Referenz manipulieren zu können.


Konsoleprogramm:
Code:
struct datentypStruct
{
   int var1;
   int var2;
   int var3;
}
datentypStruct sV;

extern "C" __declspec(dllimport) int checkeRueckgabe(datentypStruct &sV);
extern "C" __declspec(dllimport) int checkeRueckgabe2(int);

int main()
{
   sV.var3 = 100; // dient zum Test
   std::cout << checkeRueckgabe(sV) << "   = Wert aus neuer Referenz in dll." << std::endl;
   std::cout << sV.var3 << "   = Originalwert." << std::endl << std::endl;

   std::cout << checkeRueckgabe2(10) << "   = Wert aus neuer Referenz in dll addiert mit 10." << std::endl;
   std::cout << sV.var3 << "   = Originalwert." << std::endl << std::endl;

   std::cout << checkeRueckgabe2(10) << "   = Wert aus neuer Referenz in dll addiert mit 10." << std::endl;
   std::cout << sV.var3 << "   = Originalwert." << std::endl << std::endl;

   system("pause");
   return 0;
}

dll:
Code:
struct datentypStruct
{
   int var1;
   int var2;
   int var3;
}
datentypStruct temp_sV; // dient nur zum erstellen der Referenz
datentypStruct &ref_sV = temp_sV; // Referenz muss hier schon was zugewiesen bekommen. 

extern "C" __declspec(dllexport) int checkeRueckgabe(datentypStruct &sV)
{
   ref_sV = sV; // Hier soll das eigentliche Ziel der Referenz definiert werden und ab dann global in der dll zur Verfügung stehen.
   return(ref_sV.var3);
}
extern "C" __declspec(dllexport) int checkeRueckgabe2(int intVar)
{
   ref_sV.var3 = ref_sV.var3 + intVar;
   return(ref_sV.var3);
}

Grüße
 
Referenzen können, anders als Pointer, nach ihrer Definition nicht mehr umgebogen werden. Stell dir eine Referenz wie einen konstanten Zeiger (Vorsicht: nicht als einen Zeiger auf eine Konstante) vor.

Wenn du schreibst:

Code:
int a = 3;
int& refA = a;

int b = 4;
int& refB = b;

refA = refB;

dann zeigt refA auch nach der letzten Zuweisung noch auf a, auch wenn a dann den gleichen Wert wie b hat.
 
Super Erklärung danke. Dann mache ich es mit einem Zeiger dem die Adresse zugewiesen wird. Das coole ist man kann statt (*a).x mit a->x dann auf die Inhalte zugreifen und es ist genauso komfortabel wie bei einer Referenz :)
 
Zurück
Oben