Forum "C/C++" - Die Klasse Rechteck (C++) - Vorkurse

Ein Projekt von vorhilfe.de

Die Online-Kurse der Vorhilfe E-Learning leicht gemacht.
	Hallo Gast! [ einloggen \| registrieren ]
	Startseite · Mitglieder · Teams · Forum · Wissen · Kurse · Impressum

Forenbaum

Schule

VK 37: Kurvendiskussionen

VK 59: Lineare Algebra

VK 60: Analysis

Wahrscheinlichkeitst

Gezeigt werden alle Foren bis zur Tiefe 2

Navigation

Startseite...
Neuerdings beta neu
Forum...
vorwissen...
vorkurse...
Werkzeuge...
Nachhilfevermittlung beta...
Online-Spiele beta
Suchen
Verein...
Impressum

Das Projekt

Server und Internetanbindung werden durch Spenden finanziert.

Organisiert wird das Projekt von unserem Koordinatorenteam.

Hunderte Mitglieder helfen ehrenamtlich in unseren moderierten Foren.

Anbieter der Seite ist der gemeinnützige Verein "Vorhilfe.de e.V.".

Partnerseiten

Weitere Fächer:

Vorhilfe.de

FunkyPlot: Kostenloser und quelloffener Funktionenplotter für Linux und andere Betriebssysteme

Forum "C/C++" - Die Klasse Rechteck (C++)

Die Klasse Rechteck (C++) < C/C++ < Programmiersprachen < Praxis < Informatik < Vorhilfe

Ansicht:

[ geschachtelt ]

Forum "C/C++" |

Alle Foren |

Forenbaum | Materialien

Die Klasse Rechteck (C++): Korrektur, Hilfe, Tipp, Idee

Status:	(Frage) beantwortet
Datum:	13:15 Sa 27.04.2013
Autor:	Mija

Aufgabe

 Schreiben Sie ein C++-Programm, in dem eine Klasse Rechteck implementiert und getestet wird. Diese Klasse bildet ein Recheck im kartesischen Koordinatensystem mittels zweier Punkte ab: ein Punkt, der die untere linke Ecke, und ein Punkt, der die obere rechte Ecke markiert. Die Seiten des Rechtecks werden durch Geraden, die parallel zu den Achsen verlaufen, gebildet. Ein Rechteck wird also durch zwei Punkte mit Koordinaten (x,y) bestimmt. Gibt es nur einen Punkt, so wird dieser Punkt als die obere rechte Ecke betrachtet, die linke untere Ecke ist dann der Ursprung. Die Deﬁnition der Klasse in der Datei rechteck.h sowie ein Testprogramm rechteck_main.cpp ﬁnden Sie in moodle.

a) Implementieren Sie die Methoden und globalen Funktionen aus der Header-Datei. 

b) Beachten Sie, dass die Klasse mehrere Konstruktoren besitzt.

c) Der Standardkonstruktor setzt die beiden Punkte an den Ursprung.

d) Die Methode flaeche() berechnet die Fläche des Rechtecks.

e) Die Methode diagonale() berechnet die Länge der Diagonale des Rechtecks.

f) Die Methode istQuadrat() prüft, ob das Rechteck ein Quadrat ist.

g) Die Methode getMittelpunkt() berechnet und liefert den Mittelpunkt des Rechtecks zurück.

h) Die Methode ausgabe() soll die beiden Eckpunkte des Rechtecks sowie seine Fläche, Diagonale und eine Information darüber, ob das Rechteck ein Quadrat ist, ausgeben.

/* rechteck.h */
 

 
#ifndef RECHTECK_H
 
#define RECHTECK_H
 

 
struct Punkt {
 
	double x;
 
	double y;
 
};
 

 
class Rechteck {
 
private: 
 
	Punkt untenLinks;
 
	Punkt obenRechts;
 
	bool istQuadrat();
 

 
public:
 
	// Konstruktoren
 
	Rechteck();
 
	Rechteck(double xUnLi, double yUnLi, double xObRe, double yObRe);
 
	Rechteck(Punkt unLi, Punkt obRe);
 
	Rechteck(Punkt p);
 

 
	// Getter- und Setter-Methoden
 
	void setUntenLinks(Punkt p);
 
	void setObenRechts(Punkt p);
 
	Punkt getUntenLinks();
 
	Punkt getObenRechts();
 

 
	// weitere Methoden
 
	double flaeche() ;
 
	double diagonale();
 
	
 
	Punkt getMittelpunkt();
 
	void ausgabe();
 
};
 

 
void eingabePunkt(Punkt& p);
 
void ausgabePunkt(Punkt& p);
 

 
#endif // RECHTECK_H 

/* rechteck_main.cpp */
 

 
#include <iostream>
 
#include "rechteck.h"
 

 
using namespace std;
 

 
int main(void) {
 
	
 
	Punkt p1 = { 1.7, 3.4 };
 
	Punkt p2 = { 5.9, 7.6 };
 
	Rechteck r1;  
 
	r1.setUntenLinks(p1);
 
	r1.setObenRechts(p2);
 
	r1.ausgabe();
 
	cout << "----------------------------------------------------------------------------" << endl;
 

 
	eingabePunkt(p1);
 
	eingabePunkt(p2);
 
	Rechteck r2(p1, p2);
 
	r2.ausgabe();
 
	cout << "----------------------------------------------------------------------------"<< endl;
 
		
 
	Rechteck r3(-1.2, -3.4, 5.6, 7.8);
 
	r3.ausgabe();
 
	ausgabePunkt( r3.getMittelpunkt() );
 
	cout << endl;
 
	cout << "----------------------------------------------------------------------------"<< endl;
 

 
	Punkt p;
 
	eingabePunkt(p);
 
	Rechteck r4(p);
 
	r4.ausgabe();
 
	ausgabePunkt( r4.getUntenLinks() );		
 
	cout << endl;
 
	ausgabePunkt( r4.getMittelpunkt() );	
 
	cout << endl;
 
	ausgabePunkt( r4.getObenRechts()) ;		
 
	cout << endl;
 
	cout <<"----------------------------------------------------------------------------"<< endl;
 
	return 0;
 
}

Hallo, ich habe versucht die obenstehende Aufgabe zu lösen.

Wie kann ich in meine Funktionen einbringen, dass die Klasse Rechteck mehrere Konstruktoren hat?

Wegen dieser Frage ist mir noch folgendes unklar: Was muss ich in der rechteck_main.cpp bei ausgabePunkt( r4.getMittelpunkt() ); in die Klammern für getMittelpunkt schreiben? (Zeile 42 in meinem rechteck_main.cpp - Code)
Ich übergebe doch eigentlich vier double-Werte in diese Funktion. Aber hier ist nur ein Punkt p gegeben.

Außerdem habe ich das Problem, dass meine boolesche Funktion istQuadrat() bisher immer nur false zurückgibt (zumindest wird immer eine 0 ausgegeben). Wo ist da mein Fehler? (Zeile 112 in rechteck.cpp)

Ich würde mich sehr freuen, wenn mir jemand weiterhelfen könnte! :-)

Hier sind meine Codes:

1:	/* rechteck.h */
2:
3:	#ifndef RECHTECK_H
4:	#define RECHTECK_H
5:
6:	struct Punkt {
7:	double x;
8:	double y;
9:	};
10:
11:	class Rechteck {
12:	private:
13:	Punkt untenLinks;
14:	Punkt obenRechts;
15:	bool istQuadrat(double, double, double, double);
16:
17:	public:
18:	// Konstruktoren
19:	Rechteck();
20:	Rechteck(double xUnLi, double yUnLi, double xObRe, double yObRe);
21:	Rechteck(Punkt unLi, Punkt obRe);
22:	Rechteck(Punkt p);
23:
24:	// Getter- und Setter-Methoden
25:	void setUntenLinks(Punkt p);
26:	void setObenRechts(Punkt p);
27:	Punkt getUntenLinks();
28:	Punkt getObenRechts();
29:
30:	// weitere Methoden
31:	double flaeche(double, double, double, double) ;
32:	double diagonale(double, double, double, double);
33:
34:	Punkt getMittelpunkt(double, double, double, double);
35:	void ausgabe();
36:	};
37:
38:	void eingabePunkt(Punkt& p);
39:	void ausgabePunkt(Punkt& p);
40:
41:	#endif // RECHTECK_H

1:	/* rechteck.cpp */
2:
3:	#include <iostream>
4:	#include <math.h>
5:	#include "rechteck.h"
6:
7:	using namespace std;
8:
9:	// Definition der Konstruktoren
10:
11:	//Standardkonstruktor
12:	Rechteck::Rechteck()
13:	{
14:	//unten links auf 0 setzen
15:	struct Punkt pUnLi;
16:	pUnLi.x=0;
17:	pUnLi.y=0;
18:	//oben rechts aus 0 setzen
19:	struct Punkt pObRe;
20:	pObRe.x=0;
21:	pObRe.y=0;
22:	}
23:
24:	//Konstruktoren mit Parametern
25:
26:	Rechteck::Rechteck(double xUnLi, double yUnLi, double xObRe, double yObRe)
27:	{
28:	//unten links
29:	struct Punkt pUnLi;
30:	pUnLi.x = xUnLi;
31:	pUnLi.y = yUnLi;
32:	setUntenLinks(pUnLi);
33:	//oben rechts
34:	struct Punkt pObRe;
35:	pObRe.x = xObRe;
36:	pObRe.y = yObRe;
37:	setObenRechts(pObRe);
38:	}
39:
40:	Rechteck::Rechteck(Punkt unLi, Punkt obRe)
41:	{
42:	setUntenLinks(unLi);
43:	setObenRechts(obRe);
44:	}
45:
46:	Rechteck::Rechteck(Punkt p)
47:	{
48:	//unten links auf Ursprung setzen, da nur ein Punkt gegeben ist
49:	struct Punkt pUnLi;
50:	pUnLi.x = 0;
51:	pUnLi.y = 0;
52:	setUntenLinks(pUnLi);
53:	//oben rechts
54:	struct Punkt pObRe;
55:	pObRe.x = p.x;
56:	pObRe.y = p.y;
57:	setObenRechts(pObRe);
58:	}
59:
60:
61:	//Implementierung der Methoden
62:
63:
64:	// Getter- und Setter-Methoden
65:
66:	void Rechteck::setUntenLinks(Punkt p)
67:	{
68:	untenLinks = p;
69:	}
70:
71:	void Rechteck::setObenRechts(Punkt p)
72:	{
73:	obenRechts = p;
74:	}
75:
76:	Punkt Rechteck::getUntenLinks()
77:	{
78:	return untenLinks;
79:	}
80:
81:	Punkt Rechteck::getObenRechts()
82:	{
83:	return obenRechts;
84:	}
85:
86:	//andere Methoden
87:
88:	double Rechteck::flaeche(double xUnLi, double yUnLi, double xObRe, double yObRe)
89:	{
90:	double a = xObRe - xUnLi;
91:	double b = yObRe - yUnLi;
92:	return a*b;
93:	}
94:
95:	double Rechteck::diagonale(double xUnLi, double yUnLi, double xObRe, double yObRe)
96:	{
97:	double a = xObRe - xUnLi;
98:	double b = yObRe - yUnLi;
99:	return sqrt(aa+bb);
100:	}
101:
102:	Punkt Rechteck::getMittelpunkt(double xUnLi, double yUnLi, double xObRe, double yObRe)
103:	{
104:	struct Punkt M;
105:	double a = xObRe - xUnLi;
106:	double b = yObRe - yUnLi;
107:	M.x = xObRe - a/2;
108:	M.y = yObRe - b/2;
109:	return M;
110:	}
111:
112:	bool Rechteck::istQuadrat(double xUnLi, double yUnLi, double xObRe, double yObRe)
113:	{
114:	double a = xObRe - xUnLi;
115:	double b = yObRe - yUnLi;
116:	if (a==b)
117:	return true;
118:	else
119:	return false;
120:	}
121:
122:	void Rechteck::ausgabe()
123:	{
124:	cout << "x-Koordinate fuer unten links: " << untenLinks.x << endl;
125:	cout << "y-Koordinate fuer unten links: " << untenLinks.y << endl;
126:	cout << "x-Koordinate fuer oben rechts: " << obenRechts.x << endl;
127:	cout << "y-Koordinate fuer oben rechts: " << obenRechts.y << endl;
128:	cout << "Flaeche: " << flaeche(untenLinks.x, untenLinks.y, obenRechts.x, obenRechts.y) << endl;
129:	cout << "Laenge der Diagnonalen: " << diagonale(untenLinks.x, untenLinks.y, obenRechts.x, obenRechts.y) << endl;
130:	cout << "Handelt es sich um ein Quadrat (0 fuer nein, 1 fuer ja): " << istQuadrat(untenLinks.x, untenLinks.y, obenRechts.x, obenRechts.y) << endl;
131:	}
132:
133:	void eingabePunkt(Punkt& p)
134:	{
135:	cout << endl << "Geben Sie die x-Koordinate Ihres Punktes ein: ";
136:	cin >> p.x;
137:	cout << endl << "Geben Sie die y-Koordinate Ihres Punktes ein: ";
138:	cin >> p.y;
139:	cout << endl;
140:	}
141:
142:	void ausgabePunkt(Punkt& p)
143:	{
144:	cout << "Die x-Koordinate des Punktes lautet: " << p.x << endl;
145:	cout << "Die y-Koordinate des Punktes lautet: " << p.y << endl << endl;
146:	}

1:	/* rechteck_main.cpp */
2:
3:	#include <iostream>
4:	#include "rechteck.h"
5:
6:	using namespace std;
7:
8:	int main(void) {
9:
10:	//Rechteck mit vorgegebenen Punkten, ist Quadrat, Ausgabe: 1.7, 3.4, 5.9, 7.6, 17.67, 5.9397, 1
11:	Punkt p1 = { 1.7, 3.4 };
12:	Punkt p2 = { 5.9, 7.6 };
13:	Rechteck r1;
14:	r1.setUntenLinks(p1);
15:	r1.setObenRechts(p2);
16:	r1.ausgabe();
17:	cout << "----------------------------------------------------------------------------" << endl;
18:
19:	//Punkte werden selbst vom Benutzer eingegeben
20:	eingabePunkt(p1);
21:	eingabePunkt(p2);
22:	Rechteck r2(p1, p2);
23:	r2.ausgabe();
24:	cout << "----------------------------------------------------------------------------"<< endl;
25:
26:	//Rechteck mit vorgegebenen Punkten, kein Quadrat, Ausgabe: -1.2, -3.4, 5.6, 7.8, 76.16, 13.10, 0, Mittelpunkt: 2.2, 2.2
27:	Rechteck r3(-1.2, -3.4, 5.6, 7.8);
28:	r3.ausgabe();
29:	cout << "Mittelpunkt: ";
30:	ausgabePunkt( r3.getMittelpunkt(-1.2, -3.4, 5.6, 7.8) );
31:	cout << endl;
32:	cout << "----------------------------------------------------------------------------"<< endl;
33:
34:	//Punkt oben rechts wird selbst vom Benutzer eingegeben, links unten ist der Ursprung
35:	Punkt p;
36:	eingabePunkt(p);
37:	Rechteck r4(p);
38:	r4.ausgabe();
39:	cout << "Ausgabe des Ursprungs:" << endl;
40:	ausgabePunkt( r4.getUntenLinks() );
41:	cout << endl;
42:	//ausgabePunkt( r4.getMittelpunkt() ); // was kommt hier in die getMittelpunkt-Klammern??
43:	cout << endl;
44:	cout << "Ausgabe des Punktes oben rechts:" << endl;
45:	ausgabePunkt( r4.getObenRechts()) ;
46:	cout << endl;
47:	cout <<"----------------------------------------------------------------------------"<< endl;
48:	return 0;
49:	}

Bezug

Die Klasse Rechteck (C++): Mitteilung

Status:	(Mitteilung) Reaktion unnötig
Datum:	20:37 Sa 27.04.2013
Autor:	Mija

Die Frage wegen der Methoden und Konstruktoren hat sich erledigt.

Meine bool-Methode funktioniert nur leider für das erste Beispiel noch nicht. Dort müsste ja eigentlich eine 1 ausgegeben werden, denn es handelt sich um ein Quadrat.
Wenn ich allerdings in den Beispielen, wo ich selbst Punkte eingeben kann, etwas eingebe, so dass es sich um ein Quadrat handelt.. dort wird mir dann ganz brav eine 1 ausgeben.
Wo ist mein Fehler?

Kann mir denn niemand weiterhelfen?

Bezug

Die Klasse Rechteck (C++): Antwort

Status:	(Antwort) fertig
Datum:	22:29 Sa 27.04.2013
Autor:	Event_Horizon

Hallo!

Dein Problem liegt vermutlich darin, daß du zwei Doubles auf Gleichheit testest. weil sich Fließkommazahlen aus dem Dezimalsystem selten exakt in das Binärsystem übertragen lassen, gibt es da Rundungsfehler. Die sind zwar winzig, machen aber Probleme, wenn du die exakte Gleichheit überprüfen willst. Du kannst das testen:

Füge mal ein cout <<a-b<<endl; ein. Wenn die Seiten wirklich gleich sind, sollte das ja null liefern. Aber vermutlich wirst du dort winzig kleine, aber von 0 verschiedene Zahlen bekommen.

Lösen kannst du das, in dem du dir einen Schwellwert ausdenkst (sagen wir 0.000001), und nun so auf Gleichheit testest:

fabs(a-b)<0.000001

fabs liefert dir den Betrag einer Fließkommazahl.

Aber mal was anderes:

Die Klasse enthält die beiden Member-Variablen untenLinks und obenRechts. (zu sehen in der h-datei)
Darin sollst du die Punkte speichern, die per Konstruktor oder setter-Funktion übergeben werden. Und deine Funktion istQuadrat soll diese Variablen auch benutzen. Die Funktion bekommt keine vier Doubles übergeben!
Grade das macht das objektorientierte Programmieren aus. Du machst einmal ein Rechteck mit Punkten, und kannst es dann fragen, ob es ein Quadrat ist, ohne die Koordinaten nochmal anzugeben. (Das wäre dann C, nicht C++)

Das gilt natürlich auch für all die anderen Funktionen.

Bezug

Die Klasse Rechteck (C++): Mitteilung

Status:	(Mitteilung) Reaktion unnötig
Datum:	00:32 So 28.04.2013
Autor:	Mija

Vielen Dank für die Tipps! :-)

Bezug

Ansicht:

[ geschachtelt ]

Forum "C/C++" |

Alle Foren |

Forenbaum | Materialien