irgendwie habe ich Probleme einen Konstruktor für meine SUBCLASS kreis zu schreiben.

kreis(int r,int x,int y):punkt (int a,int b){};

ist mein Aufruf.

Ich bekomme die Fehlermeldung expectet primary-expression before "int"

das ganze file sieht so aus:

/*
 * punkt.h
 *
 *  Created on: 22.07.2009
 *      Author: ZANGE
 */

#ifndef PUNKT_H_
#define PUNKT_H_

#endif /* PUNKT_H_ */

#include<iostream.h>
#include<math.h>

class punkt
{
	private:
		int x; //x-koordinate des Punktes
		int y; //y-koordinate des Punktes
		float z;// Wert für den Abstand zum Nullpunkt
	public:
		punkt (int a,int b) //Konstruktor
			{x=a;y=b;};
		int print() //Ausgabe des Punktes
			{
			cout << "Die Lage des Punktes ist " <<
			x <<" Einheiten in x-Richtung\n und " <<
			y <<" Einheiten in y-Richtung!\n\n";
			};
		float abst() //Abstand zum Ursprung
			{
			z= sqrt((x*x)+(y*y));
			cout <<"Die Entfernung zum Ursprung betraegt: "
			<< z <<"\n\n";
			return z;
			};
		int move(int c, int d)//Verschieben des Punktes
			{
			x+=c;
			y+=d;
			cout <<"Der Punkt hat jetzt die Koordinaten:"
			<<"X-Achse " << x << "\n Y-Achse" << y << "\n";
			};
		punkt operator+ (const punkt &o) const
		{
			return punkt(o.x +x,o.y +y );
		};
};

class kreis: public punkt
{
	private:
		int r; //Radius des Kreises
		int x;
		int y;
		public:
		kreis(int r,int x,int y):punkt (int a,int b){};
};

Ich hoffe ihr seht meinen Fehler sofort, denn ich stehe auf dem Schlauch und wenn ich 100 tutorials durchgehe.

vielen Dank

Der Narr

/edit pumuckl: cpp-Tags dazu. bitte demnächst selber machen!

kreis(int r,int x,int y):punkt (int a,int b){};

Was willst du hier? Einen Basisklassenkonstruktor aufrufen? Dann musst du Argumente übergeben (nicht Parameter deklarieren!), die bekannt sind.

Du musst es auch nicht so eng schreiben:

kreis (int x, int y, int r) // ist m.E. konsistenter, zumal Punkt zuerst die Koordinaten nimmt
: punkt(x, y)
{
}

Übrigens: Du hast ein ziemlich schlechtes Beispiel für Vererbung gewählt. Ein Kreis ist kein Punkt! Nimm stattdessen Aggregation (Kreis besitzt einen (Mittel-)Punkt).

danke für deine schnelle Antwort. Das nächste Mal werde ich die CPP tags verwenden. Dein Tipp hat mir schon weitergeholfen.

Ich gebe dir auch vollkommen Recht einen Kreis von einem Punkt abzuleiten ist schon sehr fragwürdig.

Leider wurde die Aufgabe so vom Tutor gestellt.

Seine Erklärung war das der Kreis aus einem Punkt (Mittelpunkt) + einem Radius besteht.

Mercy

der Narr

Seine Erklärung war das der Kreis aus einem Punkt (Mittelpunkt) + einem Radius besteht.

Dann sag ihm, dass dies keine is-a Beziehung ist, sondern eine has-a. Der Kreis ist kein Punkt, sondern der Kreis hat einen Mittelpunkt.

Grüssli

Hallo Nexus,

Leider wurde die Aufgabe so vom Tutor gestellt.

Seine Erklärung war das der Kreis aus einem Punkt (Mittelpunkt) + einem Radius besteht.

Eben: "besteht", das ist Aggregation. Unter welchen Steinen werden eigentlich solche Lehrer ausgegraben?

Stefan.

danke für deine schnelle Antwort. Das nächste Mal werde ich die CPP tags verwenden. Dein Tipp hat mir schon weitergeholfen.

Ich gebe dir auch vollkommen Recht einen Kreis von einem Punkt abzuleiten ist schon sehr fragwürdig.

Leider wurde die Aufgabe so vom Tutor gestellt.

Seine Erklärung war das der Kreis aus einem Punkt (Mittelpunkt) + einem Radius besteht.

Mercy

der Narr

Seine Erklärung war das der Kreis aus einem Punkt (Mittelpunkt) + einem Radius besteht.

Vielleicht muß er mal die Geschichte von Herrn Bebel lesen: http://www.c-plusplus.net/forum/viewtopic-var-t-is-75672-and-postdays-is-0-and-postorder-is-asc-and-start-is-0.html

Mit deiner Vererbung kann man Folgendes machen:

void AbstandZumUrsprung(const Punkt& p);

int main()
{
    Kreis k(4, 5, 2); // Kreis mit Mittelpunkt (4,5) und Radius 2

    std::cout << "Abstand des Kreises vom Ursprung: ";
    std::cout << AbstandZumUrsprung(k) << std::endl!    // geht!
}

Was würde man hier erwarten? Wahrscheinlich eher den Abstand des Kreisrandes, und nicht des Mittelpunkts, oder? Ist vielleicht nicht das beste Beispiel, aber soll verdeutlichen, dass Vererbung eine semantisch starke Bindung ist, die gut überlegt sein sollte. Unter anderem eben, weil abgeleitete Objekte implizit als Basisklassenobjekte angesehen werden können.

@ Der Narr, bist du in ein Zeitloch gefallen?

// (...)
#ifndef PUNKT_H_
#define PUNKT_H_

#endif /* PUNKT_H_ */
// (...)

#include<iostream.h>
#include<math.h>

ist auch nicht mehr das aktuelleste. Besser

#include <iostream>
#include <cmath>

Das hat allerdings zur Folge, dass die Bezeichner allesamt im Namensraum std landen, du diesen mittels std:: (Bsp.: std::cout) oder using namespace std (nicht in Headerdateien) bekanntgeben musst.

Grüße... Heiko

ne bin nicht in ein Zeitloch gefallen, sondern mehr in ein Arbeitsloch

Ich bin leider noch nicht so ganz fit in C++ und OOP, aber ihr liefert mir gute und stimmige Argumente um diese Aufgabe noch mal mit meinem Tut zu diskutieren.

Gruß

der Narr

dein code ein wenig kommentiert:

class punkt 
{ 
private: 
    int x; //x-koordinate des Punktes
    int y; //y-koordinate des Punktes
    //float z;// Wert für den Abstand zum Nullpunkt --- wird berechnet
public: 
    punkt(int _x, int _y) //Konstruktor -- sollte klar sein, und somit nicht kommentiert werden...
	:	x(_x), y(_y) //nennt sich "initialisierungsliste"
	//{x=a;y=b;}; - wird somit überflüssig... das semikolon dort ist übrigens auch unnötig ^^

	punkt() : x(0), y(0) {} //einen standard konstruktor will ich auch - werd ich später zusammenfassen
	//-> schlüsselwort "explicit", damit man kein integer versehentlich in einen Punkt umgewandelt wird

    void print() //Ausgabe des Punktes -- warum int als rückgabewert? das wird dir (hoffentlich) kein compiler der welt übersetzen
    {	//eigtl würd ich hierfür aber den op<< überladen, der dann aber nur "x; y" ausgibt - aber so ists auch ok
		std::cout << "Die Lage des Punktes ist " << 
		x <<" Einheiten in x-Richtung\n und " << 
		y <<" Einheiten in y-Richtung!\n\n"; 
    }

    float abst() const //Abstand zum Ursprung -- warum print und hier dann abst und nicht distance_to_null oder so?
                   // außerdem ist die fkt jetzt mal const, weil sie nichts am objekt ändert
    { //siehe auch "const correctness" - ich werde diese methode aber betrag nennen - habs mal mit "norm" übersetzt - kA, ob das stimmt ^^
		float z = sqrt((x*x)+(y*y)); //fraglicher bezeichner, aber hier ists noch ok
		//cout <<"Die Entfernung zum Ursprung betraegt: " << z <<"\n\n"; -- hat hier nix zu suchen
		return z; 
    }

    void move(int c, int d)//Verschieben des Punktes -- gibt nichts zurück -> int durch void ersetzt
    { //hat was vom op+=, meinst du nicht?! ^^
		x += c;
		y += d;
		//cout <<"Der Punkt hat jetzt die Koordinaten:" <<"X-Achse " << x << "\n Y-Achse" << y << "\n"; -- hat hier nix zu suchen
    }

	punkt operator+ (const punkt &o) const //würde ich aus der klasse rausnehmen und über op+= implementieren
    { 
        return punkt(o.x +x,o.y +y ); 
    }
};

class kreis: public punkt //das das käse ist, hatten wir schon mal...
{ 
    private: 
        int r; //Radius des Kreises 
        int x; //??
        int y; //??
        public: 
        kreis(int r,int x,int y):punkt (int a,int b){}; //das hier ist komplett falsch - und unleserlich
};

class kreis : public punkt //das das käse ist, hatten wir schon mal...
{ 
private: 
	int r; //Radius des Kreises 
public: 
	kreis(int _x, int _y, int _r)
	:	punkt (_x, _y), r(_r)
	{}
};

wie ichs machen würde:

//punkt.h
#ifndef H_MY_PUNKT_INCLUDED_200907231648 //man sollte keine alltäglichen namen für include-guards verwenden, da gabs auch...
#define H_MY_PUNKT_INCLUDED_200907231648 //...ma nen thread mit der diskussion, wie das format wohl am besten sei, find ich aber gerad nicht

#include <cmath>
#include <iostream>

class punkt 
{ 
private:
    int x;
    int y;
public:
    explicit punkt(int _x = 0, int _y = 0)
	:	x(_x), y(_y)

	//generated copy ctor and op= works fine

	//ausgabe auf std::cout
    void print()
    { 
		std::cout << "Die Lage des Punktes ist " << x
			<< " Einheiten in x-Richtung\n und " << y
			<< " Einheiten in y-Richtung!\n" << std::endl;
    }

	//abstand zum koordinaten-ursprung
    float get_norm() const
    {
		float z = sqrt((x*x)+(y*y));
		return z; 
    }

    punkt& operator+= (const Punkt& other)
    { 
		x += other.x;
		y += other.y;
    }
};

punkt operator+ (const punkt &lhs, const punkt &rhs)
{
	punkt tmp(lhs);
    return tmp += rhs;
}

#endif //#ifndef H_MY_PUNKT_INCLUDED_200907231648

//kreis.h

#ifndef H_MY_KREIS_INCLUDED_200907231648
#define H_MY_KREIS_INCLUDED_200907231648

#include "punkt.h"

class kreis
{ 
private: 
	int r;
	punkt m;
public: 
	explicit kreis(punkt _m = punkt(), int _r = 1)
	:	m(_m), r(_r)
	{}
};

#endif //#ifndef H_MY_KREIS_INCLUDED_200907231648

ob kreis nun 3 ints oder nen punkt und nen int bekommt, ist sicherlich geschmackssache, aber ich finds so hübscher ^^
gibt sicherlich noch viel mehr, was hier geschmackssache ist... aber ich würde auf jeden fall noch ein paar getter schreiben...

falls du fragen (z.bsp. zu dem code) hast, sag bescheid...

bb

edit 1+2: 1 zeilenumbruch im kommentar hinzugefügt und nen wort hatte ich auch noch vergessen ^^

das semikolon dort ist übrigens auch unnötig ^^

Welches musst du schon verraten. Es immerhin 3 dort..

das semikolon dort ist übrigens auch unnötig ^^

Welches musst du schon verraten. Es immerhin 3 dort..

wenigsten bin ich nicht der einzige, der wörter in (auch noch kurzen ^^) sätzen vergisst

welches wird er schon merken, meinst du nicht auch? außerdem sollte er auch sehen, dass ich nach den geschweiften klammern immer das semikolon entfernt habe - und ganz doof kam er mir auch nicht vor

bb