konstruktor bei memberobjekten/vererbung???

*moon*

es geht hier um die reine theorie (lernen für eine klausur)...
keine sorge, ich will nicht, dass ihr mir meine hausaufgaben macht oder so, komme aber einfach nicht weiter, weil ich nicht weiß wie mans macht und auch nirgends ein beispiel gefunden hab...

folgendes:

gegeben sind die klassendefinitionen

class X
{
int m,n;
publi:
...
};

class Y
{
int m,n;
X x1,x2;
public:
...
};

class Z
{
int m,n;
X x1;
Y y1;
public:
...
};

es sollen folgende variablendefinitionen möglich sein:

X     x1(10,20); //x1.m=10, x1.n=20

Y     y1(11,12); //y1.m=11; y1.n=12, 1.x1.m=y1.x2.n=11, y1.x1.n=y1.x2.m=12

Z     z1(1,2,3,4); // z1.m=1, z1.n=2, z1.x1.m=1, z1.x1.n=4, z1.y1.m=3, z1.y1.n=4, z1.y1.x1.m=z1.y1.x2.n=3, z1.y1.x1.n=z1.y1.x2.m=4

man soll jetzt für X,Y,Z die konstruktoren realisieren (mit leerem rumpf)
wie geht das?

und als ob das nicht schon genug wäre, kommt als nächstes noch vererbung dazu (sonst gilt noch das was oben steht):

class Y:public X{...}

class Z:public Y{....};

wie sehen die konstruktoren aus? einmal mit den memberobjekten, und dann noch mit vererbung?

wäre über hilfe sehr dankbar!!

HumeSikkins

Hallo,
fang doch einfach mal mit X an:

X hat zwei Ints als Member, willst du beide initialisieren können, benötigst du also schon mal zwei Werte -> Konstruktor mit zwei Parametern vom Typ int:

class X 
{ 
int m,n; 
public: 
    X(int i, int j)
        : m(i)
        , n(j)
    {}
};

Y hat vier Member. Zwei ints und zwei Xs. Jedes X braucht bisher zwei Werte zur Initialisierung. Vernünftige Y-Konstruktoren wären also z.B. welche mit
2, 4, oder 6 int-Parametern oder mit 2 Int und 1 oder 2 X Parametern.
Hier nehmen wir den mit zwei int-Parametern:

class Y 
{ 
int m,n; 
X x1,x2; 
public: 
    Y(int i, int j) 
        : m(i)
        , n(j)
        , x1(i, j)
        , x2(i,j)
    {}
};

Z läuft analog.

Mit Vererbung wird das ganze auch nicht soviel schwieriger. Versuch's am Besten erstmal selbst. Als Hinweis:
Ein Basisklassenctor rufst du so auf:

class Y: public X
{
public:
     Y(int i, int j)
         : X(i, j)    // Basisklassenctor
       /*,  ... */
     {}
} ;

*moon*

wäre das richtig?

class X
{
private:
	int m,n;
public:
	X(int i, int j):m(i),n(j)
	{}
};

class Y:public X
{
private:
	int m,n;
	X x1,x2;
public:
	Y(int i, int j):X(i,j),m(i),n(j),x1(i,j),x2(j,i)
	{}
};

class Z:public Y
{
private:
	int m,n;
	X x1;
	Y y1;
public:
	Z(int i, int j, int k, int l):Y(i,j),m(i),n(j),x1(i,l),y1(k,l),y2(l,k)
};

CarstenJ

Ich denke schon, wobei naturlich noch der Body des Konstruktors fehlt und y2 nicht existiert. Ließe sich auch so nicht kompilieren...