zunächst einmal der code um den es geht (imho irrelevante dinge (wie diverse Elementfunktionen) hab ich mal der Übersichtlichkeit halber weggelassen):

class InfoDialog : public MapDialog
{
public:
	InfoDialog(HWND hParent = NULL, WORD wTemplate = NULL);
};
class MainWindow : public RootWindow
{
public:
	MainWindow();
protected:
	InfoDialog InfoDlg;
};

MainWindow soll also eine Instanz von InfoDialog enthalten. InfoDialog::InfoDialog(...) soll aber Parameter bekommen.
Folgendes ist leider nicht möglich (VC++ spuckt einen syntax fehler aus):

class MainWindow : public RootWindow
{
public:
	MainWindow();
protected:
	InfoDialog InfoDlg(hWnd, IDD_INFO); // MainWindow erbt hWnd von RootWindow!!
};

Gelöst habe ich das problem vorerst folgendermaßen:

MainWindow::MainWindow() : RootWindow(NULL)
{
	InfoDialog InfoDlgInit(hWnd, IDD_INFO);
	InfoDlg	= InfoDlgInit;
};

Diese Lösung finde ich schon äußert unbefriedigend: Das Objekt sollte sich doch eher selbst (mittels Konstruktor) initialisieren, statt eine andere Instanz diese Arbeit erledigen zu lassen und dieses dann zu kopieren.
Richtig blöd wird das ganze aber, wenn ich im Konstruktor einen Zeiger auf das aktuelle Objekt (this) woanders speichern will (brauche das für Callback als Elementfunktion). Dann muss ich zusätzlich für den Konstruktor des Initialisierungsobjekts (InfoDlgInit) einen Zeiger auf das Objektelement (MainWindow::InfoDlg) übergeben.

Wohl gemerkt, es geht mir hier nicht um den WinAPI-Kram (dafür brauche ich die Objekte halt blos), sondern darum, wie ich MainWindow::InfoDlg vernünftig initialisieren kann. Sprich: Parameter an dessen Konstruktor übergeben.

Hoffe ihr könnt mir weiterhelfen, bin leider (noch) ziemlich unerfahren..
Vielen Dank im Voraus und Gruß,
Nils.

MainWindow::MainWindow() : RootWindow(NULL), InfoDlg(hWnd, IDD_INFO)
{
}

dafür gibt es in C++ den Elementinitialisierer... schreckliches Wort.

class Bla
{
Bla(int a, int b){}
};

class Blub
{
private:
Bla a;
public:
Blub();
};

Blub::Blub() : Bla(10,20) // !
{}

MfG Eisflamme

MfG Eisflammä

class foo {
  int bar;
  foo() : bar(0) {}
};

class A
{
  A(int x){y=x};
  int y;
};
class B
{
  B(z=3):a(z)
  A a;
  int z;
};

der konstruktor von a wird aufgerufen, bevor z feststeht!

class A
{
  A(int x) : y(x) {}
  int y;
};
class B
{
  B(int wert=3) : z(wert), a(wert) {}
  A a;
  int z;
};

class A
{
  A(int x){y=x};
  int y;
};
class B
{
  B();
  A a;
  int z;
};
B::B() : a(z)
{
  z=3 // nur ein Bsp, daß hier etwas mit z passiert, DIESES z soll a initialisieren
};

class A
{
  A(int x){y=x};
  int y;
};

class B
{
  int z;
  A a;
  B();
};

B::B() : z(3), a(z)
{
}

Zu beachten ist allerdings noch etwas bei dem Konstruktor:
Damit z vor a initialisiert wird, muss z vor a deklariert sein in der Klasse. Die Reihenfolge in der Initialisierungsliste spielt keine Rolle, sondern die Reihenfolge der Deklaration der Variablen.

class A
{
  A(int x){y=x};
  int y;
};
class B
{
  B();
  int z;
  A a;
};
B::B() : z(3), a(z)
{
};

oder?

Fast! Siehe meine Anmerkung.

hab doch z vor a deklariert!

class A
{
  A(int x){y=x};
  int y;
};
class B
{
  B();
  int z;
  A a;
};
B::B() : a(z)   // funktioniert nicht wie gewollt, da z noch nicht definiert
{
  m = f();      // hier wird ein struct mit werten gefüllt
  z = g(m);     // z wird mittels dieses structs bestimmt
};

sowas dürfte funktionieren:

class A
{
  A(int x){y=x};
  int y;
};
class C
{
  int z;
  C()
  {
    m = f();      // hier wird ein struct mit werten gefüllt
    z = g(m);     // z wird mittels dieses structs bestimmt
  };
};
class B
{
  B();
  C c;
  A a;
};
B::B() : c() a(c.z)
{ 
};

für m hab ich mir mal die deklaration gespart...
im prinzip sollte es so irgendwie funktionieren, oder?
schön is das aber auch nich richtig. is dann wieder eine unnötige klasse.

noch ne andere idee, wenn ich m global mache (wäre nicht ganz unsinnig):

B::B() : a(g(m))
{
};

naja, werd mal schauen, was ich so hinbekomme. rumwurschteln hat ja eh imme rden besten lerneffekt!
jedenfalls nochmal vielen dank!

also bei der Windowsprogrammierung geht es ja eigentlich immer um irgendwelche HWND-Strukturen oder so und da konstruiert man ja nichts durch den ctor sondern setzt einfach alle Werte.
Na ja, davon abgesehen kannst du auch zur Laufzeit ein Objekt erstellen, wenn du mit Zeigern arbeitest.

class Bla
{
Bla(int a, b) {}
};

class Blup
{
private:
Bla* a;
public:
Blup(int c);
~Blup();
};

Blup::Blup(int c)
{
// mache irgendwas
a = new Bla(x, y);
}

Blup::~Blup()
{
delete a;
}

Das macht man allgemein bei dynamisch bzw. zur Laufzeit erstellten Objekten so... Zu beachten ist dann aber, dass du zu einem new natürlich immer ein delete brauchst.
Ob in deinem Fall Zeiger nötig sind, weiß ich aber gerade nicht zu beurteilen.

MfG Eisflamme

class foo {
  InfoDialog info;
public:
  foo(InfoDialog infoDlg) : info(infoDlg) {}
};

int main() {
  // HWND irgendwo erstellen
  InfoDialog info(hwnd, IDD_INFO);
  foo(info);
}

Somit hätte er dann auch das Handle initialisiert, welches seine InfoStruktur benötigt.

Hi,

also bei der Windowsprogrammierung geht es ja eigentlich immer um irgendwelche HWND-Strukturen oder so und da konstruiert man ja nichts durch den ctor sondern setzt einfach alle Werte.
Na ja, davon abgesehen kannst du auch zur Laufzeit ein Objekt erstellen, wenn du mit Zeigern arbeitest.

class Bla
{
Bla(int a, b) {}
};

class Blup
{
private:
Bla* a;
public:
Blup(int c);
~Blup();
};

Blup::Blup(int c)
{
// mache irgendwas
a = new Bla(x, y);
}

Blup::~Blup()
{
delete a;
}

Das macht man allgemein bei dynamisch bzw. zur Laufzeit erstellten Objekten so... Zu beachten ist dann aber, dass du zu einem new natürlich immer ein delete brauchst.
Ob in deinem Fall Zeiger nötig sind, weiß ich aber gerade nicht zu beurteilen.

MfG Eisflamme

dann nehmen wir aber am besten eine scoped_ptr, das hat nur vorteile:
- scoped_ptr kann nicht kopiert werden, also kann der compiler auch für unsere klasse keinen copy-ctor und copy-zuweisungs op definieren. wenn wir diese wollen, müssten wir sie sowieso selbst definiern.
- den destruktor brauchen wir nicht mehr
- falls wir noch so ein member brauchen, ist das ganze gleich exceptionsicher, ohne etra noch try-catch kaskaden zu benötigen

also:

class Blup
{
private:
boost::scoped_ptr<Bla> a;
public:
Blup(int c);
};

Blup::Blup(int c)
: a() // ctor ist explicit
{
a.reset(new Bla(x,y));
// mache irgendwas
}

für die eigentliche initialisierungsproblematik sei noch auf das hier http://www.boost.org/libs/utility/base_from_member.html verwiesen. das trifft das problem ja wohl exakt.