konstruktor

hi erstmal und ein gesundes und erfolgreiches neues jahr

ich hab folgendes problem und würde mich freuen wenn mir jemand dabei helfen würde: ich hab eine recht einfache klasse erstellt und diese mit einem standartkonstruktor versehen; zum üben habe nun einen anderen konstruktor erstellt(überladen) welcher eine änderung der werte vornimmt und die werte ansich auch neu assigned; jedoch bekomme ich es in der instanzinitialisierung nicht hin das er benutzt wird.
nun meine eigtl frage: wie kann ich bei der initialisierung die verwendung des anderen konstruktors(hat ja andere signatur) erzwingen?

hier der code dazu:

#include <iostream.h>

class punkt
{
	private:
		float x;
		float y;
    public:
		void punkt::ausgabe();						// die funktionen werden nur deklariert
		void punkt::aendern(float a,float b);		// die definition erfolgt ausserhalb der klasse
		punkt();									// standartkonstruktor(leer)
		punkt(float xx,float yy);					// "spezieller" konstruktor zum üben erstellt
		~punkt();									// destruktor(leer)
};

punkt::punkt()										// definition des standartkonstruktors
{
	x=0.0;
	y=0.0;
}

punkt::punkt(float xx,float yy)						// spezieller konstruktor
{													// den ich nicht verwendet bekommene :|
	x=xx=330.251;
	y=yy=586.243;
}

punkt::~punkt()										// definition des destruktors
{
	/* ..... */
}

void punkt::aendern(float a,float b)				// klassenname::funktion
{													// :: = bereichsoperator
	x=a;											// er kennzeichnet das die funktion zur klasse gehört
	y=b;
}

void punkt::ausgabe()								// funktion ausgabe der klasse punkt
{
	cout<<"x-Koordinate = "<<x<<endl;
	cout<<"y-Koordinate = "<<y<<endl;
}

void main()
{
	punkt p0;
	{
		cout<<"Klasse 'punkt' Instanz p0 (Keine Aenderung seit Standartkonstruktor)"<<endl;
	}
	p0.ausgabe();

	punkt p1;
	{
		cout<<"Klasse 'punkt' Instanz p1 (Wertaenderung bei der Initialisierung)"<<endl;
	}
	p1.aendern(13.0,15.2);
	p1.ausgabe();

	punkt p2;
	{
		cout<<"Klasse 'punkt' Instanz p2 (Keine Aenderung seit Spezialkonstruktor)"<<endl;
	}
	p2.ausgabe();

	punkt p3;
	{
		cout<<"Klasse 'punkt' Instanz p3 (Wertaenderung bei der Initialisierung)"<<endl;
	}
	p3.aendern(864,109.451);
	p3.ausgabe();
}

ich danke schonmal; eure seite ownt einfach nur^^
mfg rum

ZuK

punkt p1((float)1.0,(float)1.0);
K.

evilissimo

Damit du deinen Überladenen Konstruktor nutzen kannst musst du das so aufrufen:

punkt p01(13.0,15.2);
//oder
punkt *p02 = new punkt(13.0,15.2);

MfG

Horst2

genau, der konstruktor funktioniert hier ähnlich wie eine funktion.

wenn der Konstruktor

punkt(float xx,float yy);

aufgerufen werden soll, musst du ihm auch die beiden float-werte übergeben. Es wird anhand der Parameter automatisch der richtige Konstruktor ausgewählt.

mfg
Horst

hm...
also
http://home.arcor.de/incomplete/c++.jpg
hier sollten bei instanz p2 die werte vom spezialkonstruktor stehen
330.251 und 586.243

Horst2

dann musst du im code die Klasse p2 wiefolgt erstellen:

punkt p2(330.251, 586.243);

em ja genau^^ aber das war mir halt zu einfach
weil ich das ja schon in p1, welcher mit dem standartkonstruktor arbeitet,
gemacht habe

ich wollte quasie in p2 den compiler "zwingen" den spezialkonstruktor zu nehmen, wobei ich nicht ganz sicher bin ob x=xx=330.251 anerkannt wird
und in p3 dann, wird der wert wieder bei der initialisierung geändert

Horst2 schrieb:

genau, der konstruktor funktioniert hier ähnlich wie eine funktion.

wenn der Konstruktor
punkt(float xx,float yy);
aufgerufen werden soll, musst du ihm auch die beiden float-werte übergeben. Es wird anhand der Parameter automatisch der richtige Konstruktor ausgewählt.

mfg
Horst

genau aba ich hab halt keinen dunnst wie ich das korrekt ins programm bringen soll

ich meld mich jetz erstmal an, kann nicht editieren^^

Horst2

Also noch mal zur Erklärung.

Du hast z.B. 3 Konstruktoren.

Konstruktor1: punkt ();
Konstruktor2: punkt (float x, float y);
Konstruktor3: punkt (int a);

Wenn du jetzt in deinem code punkt p; benutzt, wird Konstruktor1 aufgerufen.
Schreibst du punkt p(5.2, 6.1); wird Konstruktor2 aufgerufen.
Schreibst du punkt p(25); wird Konstruktor3 aufgerufen.

Also: Der Compiler unterscheidet anhand der Parameter welcher Konstruktor der richtige ist. Man nennt das function-overloading

rum

hm ich werd mal was versuchen^^

dankÖ

Horst2 schrieb:

Also noch mal zur Erklärung.

Du hast z.B. 3 Konstruktoren.

Konstruktor1: punkt ();
Konstruktor2: punkt (float x, float y);
Konstruktor3: punkt (int a); // Der Konstruktor hier führt zu Ärger

Wenn du jetzt in deinem code punkt p; benutzt, wird Konstruktor1 aufgerufen.
Schreibst du punkt p(5.2, 6.1); wird Konstruktor2 aufgerufen.
Schreibst du punkt p(25); wird Konstruktor3 aufgerufen.

Also: Der Compiler unterscheidet anhand der Parameter welcher Konstruktor der richtige ist. Man nennt das function-overloading

// Float ist übrigens ein Datentyp mit dem man sich nur herumärgern kann.
// Wenn Du zum Beispiel später einmal Funktionen schreibst, mit denen Du
// etwa vergleichen möchtest, ob zwei Punkte identisch sind, und die beiden
// Punkte durch irgendwelche Berechnungen zustande gekommen sind, dann ist
// es aufgrund der Rundungsfehler praktisch sicher, dass niemals zwei Punkte
// identisch sind, auch dann nicht, wenn sie es eigentlich sein müssten.
// vielleicht überlegst Du Dir, als Datentypen für die Koordinaten des Punktes
// ganzzahlige Werte zu verwenden, dann kannst Du mit den Punkten getrost
// rechnen, solange du willst - keine Rundungsfehler == nie wieder falsche
// Resultate. Wenn Du allerdings bei Deinen Berechnungen unbedingt Wurzel-
// ziehen musst, dann versuch mal eine Struktur wie die folgende zu ver-
// wenden:

class Rundungssicher{
 public:
 long ZaehlerBasis;
 long NennerBasis;
 long ZaehlerExponent;
 long NennerExponent;
 };

Eine Zahl in dem dem Format (Basis ist rational, Exponent ist auch rational)
würde beipielsweise eine Quadratwurzel von 7 so speichern ...
ZaehlerBasis=7;
NennerBasis=1;
ZaehlerExponent=1;
NennerExponent=2;
// ... also auch erlauben, beliebige reelle Zahlen (auch die irrationalen)
// ... 'ganzzahlig zu machen', also Rundungsfehler prinzipiell auszu-
// ... schließen. Ist vielleicht auch eine sehr gute Übung, die Operatoren
// ... und ein Bündel praktischer Funktionen für so einen Datentyp zu
// ... schreiben, um einfach einmal die Syntaxkenntnisse zu trainieren.
// ... Und das tolle an der Übung ist dass Du dann eine Bibliothek hast,
// ... die einen äußerst flexiblen Datentyp für Reelle Zahlen bereitstellt,
// ... und auf die Du dann noch oft zurückgreifen wirst.

// Wie gesagt, float oder double sind wirklich nur Notlösungen, spätestens
// wenn's an geometrische Aufgaben geht, wird's Zeit, dem Rundungsfehler
// den Schneid abzukaufen.

// Bezüglich Deiner Punkt-Klasse:
// Ansonsten sollte man sich das Schreiben von Konstruktoren, die mit nur
// einem einzigen Parameter aufgerufen werden können, immer doppelt über-
// legen. Die werden dann nämlich mitunter einfach zum Konvertieren des
// Paramtertyps in den Typ deiner Klasse verwendet, das generiert dann
// oft äußerst schwer zu findende Fehler.

camper

und wie würde bei so einem datentyp eine addition aussehen (selbstverständlich rundungssicher) ? du wirst schnell feststellen, dass du algebraische zahlen höchtens mit dynamischen datentypen rundungssicher in den griff bekommst...

finix

HansImSuff schrieb:

// Bezüglich Deiner Punkt-Klasse:
// Ansonsten sollte man sich das Schreiben von Konstruktoren, die mit nur
// einem einzigen Parameter aufgerufen werden können, immer doppelt über-
// legen. Die werden dann nämlich mitunter einfach zum Konvertieren des
// Paramtertyps in den Typ deiner Klasse verwendet, das generiert dann
// oft äußerst schwer zu findende Fehler.

Für genau solche sorgen existiert das Schlüsselwort explicit