(Gelöst) Mit Pointer von Struktur in DLL Methode aud Struktur zugreifen

Reilsss

Hallo,
ich habe eine kleine Anwendung geschrieben die im Hauptprogramm eine Struktur erstellt, mit Datenfühlt und einen Pointer auf die Struktur stellt.
Die Anwendung soll dann eine Methode in einer selbsterstellten DLL aufrufen, welche mit hilfe des Pointers auf die Daten der Struktur zugreifen soll.

Wie man das macht wenn Methode und Struktur in einem Projekt sind habe ich schon heraus gefunden. Ich erhalte jegendlich die fehler Meldung:

Error C2664: 'Unmanaged_Code::Unmanaged_Class::Change_Struct': Konvertierung des Parameters 1 von 'struktur_layout *' in 'Unmanaged_Code::struktur_layout_in_dll *' nicht möglich

Soweit ich dies verstehe soll ich eine Pointer übergeben aber es ist doch schon ein Pointer den ich weiterleiten möchte??

Kann mir jemand bitte sagen welchen fehler ich mache?

Hier mein bisheriger Quellcode:

/* ****************************************
 * Konsolen Anwendung für Unamanged C++
 * als Win32 Aplikation, zum überprüfen
 * von C++ code und Lernen von C++
 * **************************************** */

#pragma once //Quellcode wird nur einmal Kompiliert

#include <iostream> //Input / Output Streams

#include "Unmanaged.h" //Headerdatei aus der DLL

/* ****************************************
 * Verwendete Namespaces
 * **************************************** */
using namespace std; //std Namespace von <iostream> verwenden

/* ******************
 * Struktur Festlegen
 * ****************** */
struct struktur_layout { // Struktur Festlegen 
	int int_Zahl;
	double dbl_Zahl;
	std::string str_Text;
};

//Strukttur <--> Zeiger Test Funktion
void Struktur_Pointer_Test(struct struktur_layout *);

/* ****************************************
 * Hauptfunktion der Win32 Konsolen
 * Anwendung.
 * **************************************** */
int main()
{
	//Variabeln Deklaraion
	//********************
	int programmende;
	double a = 7.4;
	int b = 99;

	int int_wert = 5;
	double dbl_wert = 10;
	std::string str_satz = "dies ist ein Test String.";

	//Struktur verändern über DLL
	//***************************

	struktur_layout struktur, *struktur_pointer; //Neue Struktur mit Pointer Initzialisieren
	struktur_pointer = &struktur; //Adresse der Struktur an Pointer geben
	struktur.int_Zahl = 10; //Struktur mit Daten befühlen
	struktur.dbl_Zahl = 1.1;
	struktur.str_Text = "das ist der start String";

	//Struktur über DLL verändern
	//Unmanaged_Code::Unmanaged_Class::Change_String(struktur_pointer);

	//Ausgabe der Struktur
	cout << "Vor Änderungen der dll: Struct Int Zahl: " << struktur.int_Zahl << endl;
	cout << "Vor Änderungen der dll: Struct Double Zahl: " << struktur.dbl_Zahl << endl;
	cout << "Vor Änderungen der dll: Struct String Satz: " << struktur.str_Text << endl;

	//Struktur_Pointer_Test(struktur_pointer); //Testfunktion geht
	Unmanaged_Code::Unmanaged_Class::Change_Struct(struktur_pointer);
	//Aufruf der Methode in der DLL leider funktioniert übergabe des Pointer nicht

	//Ausgabe der Struktur
	cout << "Nach Änderung der dll: Struct Int Zahl: " << struktur.int_Zahl << endl;
	cout << "Nach Änderung der dll: Struct Double Zahl: " << struktur.dbl_Zahl << endl;
	cout << "Nach Änderung der dll: Struct String Satz: " << struktur.str_Text << endl;

	//Ende
	//****
	//Eingabe um Konsole on screen zu halten
	cin >> programmende;
}

//Strukttur <--> Zeiger Test Funktion
void Struktur_Pointer_Test(struct struktur_layout * struktur_pointer)
{
	(*struktur_pointer).int_Zahl = (*struktur_pointer).int_Zahl + 1;
	(*struktur_pointer).dbl_Zahl = (*struktur_pointer).dbl_Zahl * 1.1;
	(*struktur_pointer).str_Text = "Hallo " + (*struktur_pointer).str_Text;
}

Header meiner DLL Datei:

/* ****************************************
 * Unmanaged Class (C++ Header)
 * **************************************** */

#pragma once //Quellcode wird nur einmal Kompiliert

#include <string> //Klasse um den Datentype String verwenden zu können

using namespace std; //C++ Standardnamespace

/* ****************************************
 * Prototyp des Namespace und der Klassen
 * **************************************** */
namespace Unmanaged_Code
{
	class Unmanaged_Class
	{
	public:
		//Methoden
		//********
		//struct
		static __declspec(dllexport) void Unmanaged_Class::Change_Struct(struct struktur_layout_in_dll *);
	};
}

Und Quellcode meiner dll

/* ****************************************
 * Unmanaged Class (C++ Quellcode)
 * Unmanaged.cpp : Definiert die exportierten Funktionen für die DLL-Anwendung.
 * **************************************** */

/* ****************************************
 * Zusätzliche Klasse
 * **************************************** */
#include <stdexcept>
//#include "stdafx.h"
#include <iostream> //Klasse für ein und Ausgabe
#include "Unmanaged.h" //Header von Unmanaged

using namespace std; //C++ Standardnamespace

/* ****************************************
 * Unmanaged Code Namespace
 * **************************************** */
namespace Unmanaged_Code
{
	/* ****************************************
	 * Methoden zum verändern von Strukturen
	 * **************************************** */

	//Definieren der Struktur
	struct struktur_layout_in_dll {
		int int_Zahl;
		double dbl_Zahl;
		std::string str_Text;
	};

	//Methode zum annehmen, verändern und zurücksenden von Strukturen
	void Unmanaged_Class::Change_Struct(struct struktur_layout_in_dll * struktur_pointer)
	{
		struktur_pointer->int_Zahl = struktur_pointer->int_Zahl + 999;
		struktur_pointer->dbl_Zahl = struktur_pointer->dbl_Zahl * 100;
		struktur_pointer->str_Text = "Hey " + struktur_pointer->str_Text;
	}

}

drakon

Das sagt doch die Fehlermeldung bereits?! Das sind inkompatible Typen.

Die Funktion:

void Unmanaged_Class::Change_Struct(struct struktur_layout_in_dll * struktur_pointer)

erwartet struktur_layout_in_dll , aber bekommt in Zeile 67 ein struktur_layout struktur .

Was verstehst du daran nicht?

Reilsss

Da ich neu in C++ bin dachte ich das wenn ich die beiden Strukturen exakt gleich aufgebaue, das es dann mölich sein würde den Pointer zu übergeben. Dem ist offensichtlich nicht so.
Wenn ich in der dll Datei auf die struktur_layout struktur verweise, kann ich die dll nicht mehr Kompilieren da für die DLL die Struktur des Hauptprogramm zum Zeitpunkt der Kompilierung unbekannt ist. (Soweit ich weis muss ich erst DLL erstellen und dann in Hauptprogramm einbinden.
Es müsste doch aber möglich sein von der dll aus die Struktur des Hauptprogramm verändern zu können in dem man der DLL eine Pointer übergibt, oder muss ich bereits hier ein Marshalling zwischen Hauptprogramm und DLL ausüben?

Maxi

nein, brauchste nicht.

Wenn du deine Struktur im Header definierst und diesen Header in sowohl dll als auch hauptprogramm einbindest, dann kannst du die Struktur in beiden Modulen benutzen. Du musst dann natürlich auch genau diese Struktur nutzen und nicht zwei verschiedene, die nur gleich aufgebaut sind.

Reilsss

Danke für den Tipp. Nachdem ich die definition der Struktur in den Header der DLL Datei geschrieben habe, und über diesen die Struktur erstelle geht es nun.
Danke nochmal für die schnelle Hilfe!