const double kPi = 3.14159265;
const double kGenauigkeit = 0.000001;

class Winkel {

	public:

		Winkel();
	//	Winkel(double grad);
		virtual double Value() = 0;
		virtual void SetValue(double gradZahl) = 0;	

	protected:

		double fGrad;
};	

class RadWinkel;

class GradWinkel : public Winkel {

	public:
		GradWinkel();
		GradWinkel(RadWinkel* radWinkel);

		virtual double Value();
		virtual void SetValue(double gradZahl);
};

class RadWinkel : public Winkel {

	public:
		RadWinkel();
		virtual double Value();
		virtual void SetValue(double gradZahl);

};

//================================================
// * Funktionen * 
//================================================

Winkel::Winkel()
{
	fGrad = 0;
}

/*
Winkel::Winkel(double grad)
{
	fGrad = grad;
}

*/
GradWinkel::GradWinkel()
{

}

RadWinkel::RadWinkel()
{
}

GradWinkel::GradWinkel(RadWinkel* radWinkel)
{

}

double GradWinkel::Value()
{
	return fGrad;
}

double RadWinkel::Value()
{
	return ((fGrad * kPi) / 180);
}

void GradWinkel::SetValue(double gradZahl)
{	
	fGrad = gradZahl;
}

void RadWinkel::SetValue(double gradZahl)
{

}

//=================================================
// * Tests * 
//=================================================

XGTEST(easy, Winkel)
{
	GradWinkel *gradWinkel = new GradWinkel;
	XGDOUBLES_EQUAL(gradWinkel->Value(), 0,	kGenauigkeit);
}

XGTEST(verweis, Winkel)
{
	RadWinkel *radWinkel = new RadWinkel;
	XGDOUBLES_EQUAL(radWinkel->Value(), 0, kGenauigkeit);

	GradWinkel *gradWinkel = new GradWinkel(radWinkel);

	gradWinkel->SetValue(90);
	XGDOUBLES_EQUAL(kPi / 2, radWinkel->Value(), kGenauigkeit);

/*	gradWinkel->SetValue(270);
	XGDOUBLES_EQUAL(radWinkel->Value(), kPi + kPi / 2, kGenauigkeit);

	radWinkel->SetValue(kPi);
	XGDOUBLES_EQUAL(gradWinkel->Value(), 90, kGenauigkeit);*/
}

wenn hier der 2. test bei xgtest(verweis,..) aufgerufen wird, springt er immer in den konstruktor von Winkel undnicht zb von RadWinkel. wieso? und wie muss ich den konstruktor von GradWinkel(RadWinkel* radWinkel) definieren?!

mfg

Davon ab - code-tags helfen, cpp-tags noch 'n Stückchen mehr und Source auf das wesentliche reduzieren sowieso

wie man virtuelle Konstruktoren simulieren kann, steht hier:
Mehr effektiv C++ programmieren | ISBN: 3827312752

Kapitel 5.1

Die Frage ist aber, ob das dein Problem beheben würde. Wieso meinst du denn, dass der Konstruktor von GradWinkel nicht aufgerufen wird?

und ich weiss auch nicht wie ich den konstruktor von GradWinkel definieren soll.. was der überhaupt machen soll..

Winkel::Winkel(double grad) : fgrad(grad) {}

GradWinkel::GradWinkel(double grad) : Winkel(grad) {}
GradWinkel::GradWinkel(const RadWinkel& rw) : Winkel(rw.Value()) {}

RadWinkel::RadWinkel(double rad) : Winkel(rad*180/kPi) {}
// g/360 = r/2 pi -> g = r*180/pi

Btw, nach deinem Quelltext würde ich nicht davon ausgehen, daß sich die Werte zweier verschiedener Winkel automatisch gegenseitig aktialisieren.

Bye, TGGC (Demo or Die)

Konstruktoren kann man nicht virtuell machen, wie auch, denk doch mal nach! Aber wie wäre eine virtuelle InitBla Methode?

Hm, eine virtuelle Init-Methode? Finde ich kacke, das hat man früher gemacht... also mal nachdenken. Vielleicht mit ner Factory-Methode, die anhand der Argumente entscheidet welche Klasse sie instanziiert? Jo, das könnte funktionieren. Dürfte so auch im bereits verlinkten Buch beschrieben sein un dläuft tatsächlich unter dem Namen virtueller Konstruktor.

class Winkel
{
public:
	Winkel(long double val) : grad(val) { }
protected:
	long double grad;
};

class GradWinkel : Winkel
{
	GradWinkel(long double grad) : Winkel(grad) { }
	void set(long double val) { grad = val; }
	long double get() const { return grad; }
};

Ich sag mal meine Meinung zu dem Beispiel:
- Irgendwie unglücklich gewählt. Es scheint als ob man das nicht in einem Projekt braucht, sondern zu Übungszwecken schreibt. Es wäre doch einfacher eine Klasse Winkel zu erstellen und diese dann mit den entsprechenden Methoden zu füllen (toRad, toGrad...)
- Ich würde die set/get Methoden nicht schon in der Basisklasse definieren.

Gruß

wie macht man das ?

aber ich habe jetzt ein andres poblem..

in dem gradwinkel objekt stecken alle infos drin die ich brauche, dort wird fGrad auf 90 gesetzt.
da aber beim 3. test radwinkel die funktion value aufruft, habe ich die infos nicht.. weil in einem radwinkel objekt fGrad = 0 ist..

wie kann ich jetzt dem radwinkel objekt die infos geben? durch den speicher? mit einem verweis? also zeiger?!

wie schreibt man das syntaktisch?

Wie wär's mit einer einfachen Winkelklasse, die setGrad und setRad anbietet?
Und auch getGrad und getRad. Intern kannste dann speichern wie Du willst und nur beim setten/getten mußte halt entpsrechend umrechnen.

MfG Jester

kann mir einer sagen wie ich das dann mache:

Der GradWinkel bekommt ja als Parameter beim Konstruktor einen Verweis
auf seinen Kumpel, den RadWinkel.

Wenn der GradWinkel nun auf einen Wert, zum Beispiel 90° gesetzt wird,
soll genau dieser Kumpel, der RadWinkel dann exakt diesen Wert in
Radiant bekommen.

class winkel
{
public:
  winkel(double rad) : val(rad) {}
  void setRad(double rad) {val=rad;}
  void setGrad(double grad) {val=grad*kPi/180;}
  double getRad() {return val;}
  double getGrad() {return val*180/kPi;}
private:
  double val; // Winkelwert in rad
}

(OK, der hat keinen Konstruktor für Grad-Angaben, aber das lässt sich sicher auch umgehen)

ja ich muss das aber so machen wies in den tests steht..

aber wir können abweichen und aufhören mit dem unfug. vielleicht kannste deinem dozenten auch einen dezenten link auf diesen thread zukommen lassen.

mir scheint, die meisten c++-langsam-lerner werden von dozenten gemacht, die völlig unpassende beispiele nehmen.

ich rate dringend davon ab, das beispiel weiter fortzuführen.
du wirst die vererbung an dem winkelbeispiel erstens nicht begreifen und zweitens auch noch für zukünftige beispielr verdorben.