THzMessungDlg.cpp

ThzMeasurement*  Measurement = new ThzMeasurement(theApp.Verschiebetisch, &theApp.Settings);

mit
ThzMessung.h

class CTHzMessungApp : public CWinApp
{
public:
	CTHzMessungApp();
	~CTHzMessungApp();
...
private:
	struct structSettings {
		MicosSettings micos;
	};

public:
	MicosPosCtrl* Verschiebetisch;
	structSettings Settings;
};

ThzMeasurement.h

// Geräte
#include "MicosPosCtrl.h"
// Einstellungen
#include "MicosSettings.h"

class ThzMeasurement
{
private:
struct structSettings 
	{
		MicosSettings micos;
	};

public:
	ThzMeasurement(MicosPosCtrl* newVerschiebetisch, structSettings* newSettings);
	~ThzMeasurement(void);

private:
	int m_Status;
	MicosPosCtrl* Verschiebetisch;
	structSettings* Settings;

};

ThzMeasurement.cpp

#include "ThzMeasurement.h"

ThzMeasurement::ThzMeasurement(MicosPosCtrl* newVerschiebetisch, structSettings & newSettings)
{
	Verschiebetisch = newVerschiebetisch;
	Settings = newSettings;
}

das führt allerdings zu dem Fehler:

1>z:\cpp\thz\thzmessung\thzmessung\thzmessungdlg.cpp(131) : error C2664: 'ThzMeasurement::ThzMeasurement(MicosPosCtrl *,ThzMeasurement::structSettings *)': Konvertierung des Parameters 2 von 'CTHzMessungApp::structSettings *__w64 ' in 'ThzMeasurement::structSettings *' nicht möglich
1> Die Typen, auf die verwiesen wird, sind nicht verknüpft; die Konvertierung erfordert einen reinterpret_cast-Operator oder eine Typumwandlung im C- oder Funktionsformat.

wie löse ich dieses Problem ?

Matthias

... indem Du dieselbe Klasse nimmst, wenn Du dieselbe Klasse nehmen willst.
Wie die COmpiler Fehlermeldung schon sagt, sind A::X und B::X vollkommen unterschiedliche Klassen, die nichts miteinander zu tun haben .... auch wenn sie beide X heißen und von Dir vielleicht auf dieselben Member bekommen.

Lösung A : structSettings aus den Klassen in den umgebenden namespace lösen.

Lösung B : "gegenseitige Konstruktoren" bauen:

class CTHzMessungApp : public CWinApp
{
    struct structSettings {
        structSettings(ThzMeasurement::structSettings const& m) : micos(m.micos) {}
        MicosSettings micos;
    };
...

Hier müsstest Du allerdings Deinen "private"-Schutz aufgeben (zumindestens "befrienden") und sollest auch passende operator=() implementieren. Ich glaube mal, dass Du das nicht brauchst/willst.

Ach ja: Kommst Du von Java oder warum hantierst Du so viel mit new ?

Gruß,

Simon2.

Hi,
... indem Du dieselbe Klasse nimmst, wenn Du dieselbe Klasse nehmen willst.

schon klar, nur die Lösung war mir nicht offensichtlich.

Simon2 schrieb:

Lösung A : structSettings aus den Klassen in den umgebenden namespace lösen.

verstehe ich nicht.
Wenn ich structSettings nicht in der Klasse definiere ist es in der nächsten Klasse nicht mehr bekannt und wenn ich es dort ebenfalls nicht in der Klasse definere ist es zweimal definiert.

Simon2 schrieb:

Lösung B : "gegenseitige Konstruktoren" bauen:

class CTHzMessungApp : public CWinApp
{
    struct structSettings {
        structSettings(ThzMeasurement::structSettings const& m) : micos(m.micos) {}
        MicosSettings micos;
    };
...

Hier müsstest Du allerdings Deinen "private"-Schutz aufgeben (zumindestens "befrienden") und sollest auch passende operator=() implementieren. Ich glaube mal, dass Du das nicht brauchst/willst.

Kannst du das weiter erläutern. Ich verstehe das Konstrukt nämlich nicht.

Simon2 schrieb:

Ach ja: Kommst Du von Java oder warum hantierst Du so viel mit new ?

Nein ich habe von Java praktisch gar keine Ahnung

Matthias

OK, dann mal Lösung A (finde ich sowieso besser ;):

structSettings.h

struct structSettings {
   MicosSettings micos;
};

CTHzMessungDlg.cpp

#include "CThzMessungApp.h"
CTHzMessungApp theApp;
ThzMeasurement  Measurement(theApp.Verschiebetisch, theApp.Settings);

(Ich denke mal, dass Du hier keine globalen Variablen anlegst, oder doch ? )

mit
CThzMessungApp.h

#include "structSettings.h"
class CTHzMessungApp : public CWinApp
{
public:
   structSettings Settings;
};

ThzMeasurement.h

// Geräte
#include "MicosPosCtrl.h"
// Einstellungen
#include "MicosSettings.h"

#include "stuctSettings.h"
class ThzMeasurement
{
public:
   ThzMeasurement(MicosPosCtrl* newVerschiebetisch, structSettings const& newSettings); 
private:
   int m_Status;
   MicosPosCtrl* Verschiebetisch;
   structSettings Settings;
};

ThzMeasurement.cpp

#include "ThzMeasurement.h"

ThzMeasurement::ThzMeasurement(MicosPosCtrl* newVerschiebetisch, structSettings const& newSettings)
      : m_Status(0), Verschiebetisch(newVerschiebetisch), Settings(newSettings) {} // s."Initialisierungsliste"

Gruß,

Simon2.

Die Loesung B ist ein Umwandlungskonstruktor. das Struct A::structSettings kann einem B::structSettings als Konsturktorargument uebergeben werden und umgekehrt, wenn du die entsprechenden Konstruktoren definierst. Dann kannst du, wenn du das eine von beiden erwartest, das andere uebergeben. Es wird dann dank des vorhandenen Konstruktors implizit umgewandelt. Dazu muss aber bei beiden Klassen structSettings public deklariert sein (muss es sowieso wenn du es wie geplant an deinen Konstruktor uebergeben willst). Ich halte das aber fuer keine so elegante Loesung, weil es erstens die Typsicherheit aufweicht und zweitens nur ein etwas undurchdachtes Design verschlimmbessert.

Ich wuerde folgendes machen:
Da deine beiden KLassen nicht nur einen sehr aehnlichen Namen sondern auch gleiche Member haben, vermute ich, dass sie eng miteinander verwand sind. Da bietet sich eine gemeinsame Klassenhierarchie oder eine Komposition von Klassen an.
Wenn das structSettings ein wichtiger Bestandteil beider Klassen ist, solltest du auch es als ein einzxelnes Konzept behandeln, nicht als zwei private Konzepte von zwei Klassen, die fuer den Compiler nichts miteinander zu tun haben.