Informatiker Board | Druckvorschau: Rumpf Implementierungen

Geschrieben von proggerisBack am 18.03.2016 um 12:06:

Rumpf Implementierungen

hallo Guten Tag ich habe wieder bei einer neuen Aufgabe probleme:

Es soll eine Klasse CRectangle implementiert werden, die ein Rechteck modelliert. Das Rechteck wird durch die Eigenschaften „linke untere Ecke“, „rechte obere Ecke“ und ein „Füllzeichen“ beschrieben, das später für die graphische Darstellung (s. u.) verwendet wird. Die Klasse CPoint zur Repräsentation einer Koordinate ist bereits vorgegeben. Verändern Sie den Quellcode dieser Klasse nicht! Die Klassendefinition der Klasse CRectangle ist ebenfalls bereits vorgegeben. Beachten Sie die Hinweise in den Kommentaren der Klassendefinition.

Hier die rumpf implementierungen:

code:

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:

#ifndef ASCIISCREENSOLUTION_MYCODE_CRECTANGLE_H_
#define ASCIISCREENSOLUTION_MYCODE_CRECTANGLE_H_

#include <ostream>
using namespace std;

#include "CPoint.h"
#include "CScreen.h"

/**
 * Diese Klasse beschreibt ein Rechteck in einem
 * Ganzzahl-Koordinatensystem über die Eigenschaften
 * "untere linke Ecke" und "obere rechte Ecke".
 *
 * Als zusätzliche Eigenschaft hat die Klasse ein Zeichen
 * (char) das bei der graphischen Darstellung als
 * Füllzeichen verwendet wird.
 */
class CRectangle
{
private:
	/** Die linke untere Ecke. */
	CPoint m_bottomLeft;
	/** Die rechte obere Ecke. */
	CPoint m_topRight;
	/** Das Füllzeichen für die graphische Darstellung. */
	char m_fillChar;

public:
	/**
	 * Erzeugt ein neues Rechteck mit linker unterer und
	 * rechter oberer Ecke bei (0,0) und dem angegebenen
	 * Füllzeichen.
	 */
	CRectangle(char fillChar = '#');

	/**
	 * Erzeugt ein neues Rechteck mit der angegebenen linken
	 * unteren und rechten oberen Ecken sowie dem angegebenen
	 * Füllzeichen.
	 *
	 * Beim Erzeugen wird die Zusicherung überprüft, dass die
	 * rechte obere Ecke rechts von und oberhalt der linken
	 * unteren Ecke liegen muss! Falls die x-Koordinate
	 * der rechten oberen Ecke nicht größer als die x-Koordinate
	 * der linken unteren Ecke ist, wird sie auf den Wert
	 * der x-Koordinate der linken unteren Ecke gesetzt. Falls
	 * die y-Koordinate der rechten oberen Ecke nicht größer als
	 * die y-Koordinate der linken unteren Ecke ist, wird sie auf
	 * dem Wert der y-Koordinate der linken unteren Ecke gesetzt.
	 */
	CRectangle(CPoint bottomLeft, CPoint topRight, char fillChar = '#');

	/**
	 * Weist den Eigenschaften "linke untere Ecke" und "rechte obere
	 * Ecke" neue Werte zu.
	 *
	 * Vor der Zuweisung wird die Zusicherung überprüft, dass die
	 * rechte obere Ecke rechts von und oberhalt der linken
	 * unteren Ecke liegen muss! Ist das nicht der Fall wird keines
	 * der Attribute verändert.
	 */
	void setCorners (CPoint bottomLeft, CPoint topRight);

	/**
	 * Liefert die linke untere Ecke des Rechtecks zurück.
	 */
	CPoint getBottomLeftCorner() const;

	/**
	 * Liefert die rechte obere Ecke des Rechtecks zurück.
	 */
	CPoint getTopRightCorner() const;

	/**
	 * Weist dem Füllzeichen den angegebene Wert zu.
	 */
	void setFillChar(char fillChar = '#');

	/**
	 * Liefert den Wert des Füllzeichens.
	 */
	char getFillChar() const;

	/**
	 * Prüft, ob die beiden Rechtecke in allen Eigenschaften übereinstimmen.
	 */
	bool operator== (const CRectangle& other) const;

	/**
	 * Zeichnet das Rechteck in das übergebene Bildschirmobjekt. Das heisst,
	 * es werden mit CScreen::setPoint die Werte aller "Punkte", die im 
	 * Bereich des Rechtecks liegen, auf das Füllzeichen des Rechtecks gesetzt.
	 */
	void draw(CScreen& screen) const;

	/**
	 * Gibt eine textuelle Darstellung des Rechtecks auf dem übergebenen
	 * Ausgabestrom aus. Das Format ist in der Aufgabenstellung beschrieben.
	 */
	friend ostream& operator<< (ostream& lhs, const CRectangle& rhs);
};

#endif /* ASCIISCREENSOLUTION_MYCODE_CRECTANGLE_H_ */

cpp

code:

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:

#include "CRectangle.h"

CRectangle::CRectangle(char fillChar)
{
	m_fillChar = fillChar;
}

CRectangle::CRectangle(CPoint bottomLeft, CPoint topRight, char fillChar)
{
	// Bitte implementieren
}

void CRectangle::setCorners(CPoint bottomLeft, CPoint topRight)
{
	// Bitte implementieren
}

CPoint CRectangle::getBottomLeftCorner() const
{
	// Bitte implementieren und dabei das return-Statement ersetzen.
	return CPoint();
}

CPoint CRectangle::getTopRightCorner() const
{
	// Bitte implementieren und dabei das return-Statement ersetzen.
	return CPoint();
}

void CRectangle::setFillChar(char fillChar)
{
	// Bitte implementieren
}

char CRectangle::getFillChar() const
{
	// Bitte implementieren und dabei das return-Statement ersetzen.
	return 0;
}

bool CRectangle::operator ==(const CRectangle& other) const
{
	// Bitte implementieren und dabei das return-Statement ersetzen.
	return false;
}

void CRectangle::draw(CScreen& screen) const
{
	// Bitte implementieren
}

Stimmt mein Konstruktor soweit ?

code:

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:


#include "CRectangle.h"

CRectangle::CRectangle(char fillChar)
{
	m_fillChar = fillChar;
}

CRectangle::CRectangle(CPoint bottomLeft, CPoint topRight, char fillChar)
{
	if(x.topRight<x.bottomLeft){

		m_x.bottomLeft = x.bottomLeft;
	}
	if(y.topRight<y.bottomLeft){

			m_y.bottomLeft = y.bottomLeft;
		}
}

void CRectangle::setCorners(CPoint bottomLeft, CPoint topRight)
{
	// Bitte implementieren
}

CPoint CRectangle::getBottomLeftCorner() const
{
	// Bitte implementieren und dabei das return-Statement ersetzen.
	return CPoint();
}

CPoint CRectangle::getTopRightCorner() const
{
	// Bitte implementieren und dabei das return-Statement ersetzen.
	return CPoint();
}

void CRectangle::setFillChar(char fillChar)
{
	// Bitte implementieren
}

char CRectangle::getFillChar() const
{
	// Bitte implementieren und dabei das return-Statement ersetzen.
	return 0;
}

bool CRectangle::operator ==(const CRectangle& other) const
{
	// Bitte implementieren und dabei das return-Statement ersetzen.
	return false;
}

void CRectangle::draw(CScreen& screen) const
{
	// Bitte implementieren
}

Ich hoffe jemand kann mir helfen?

Geschrieben von eulerscheZahl am 18.03.2016 um 12:32:

Ich habe den Verdacht, dass da etwas fehlt (z.B. CPoint.h und CScreen.h, CRectangle.h).
Lade bitte alles, was du hast, als .zip hoch.

Geschrieben von proggerisBack am 18.03.2016 um 12:39:

Es handelt sich um eine Übungsklausur .

Hab alles angehängt .

Stimmt aber der Konstruktor schon mal?

Geschrieben von eulerscheZahl am 18.03.2016 um 12:42:

"Die Klasse CScreen [...] ist bereits vorgegeben".
Wo ist die?

Geschrieben von progger am 18.03.2016 um 12:45:

Eine Klasse CScreen war bei der Klausur eigentlich nicht vorgegeben .

Aber ich habe als Lösung die header.

code:

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:

#ifndef ASCIISCREENSOLUTION_MYCODE_CSCREEN_H_
#define ASCIISCREENSOLUTION_MYCODE_CSCREEN_H_

#include "CPoint.h"

/**
 * Dies Klasse repräsentiert einen Bereich von 80x24 "Punkten",
 * die als ein beliebiges Zeichen dargestellt werden können.
 */
class CScreen
{
private:
	/** Der Speicher für die Darstellung der Punkte. */
	char m_content[24*80];

public:
	/**
	 * Erzeugt eine neue Darstellung, bei der alle Punkte
	 * auf den Wert '.' gesetzt sind.
	 */
	CScreen();

	/**
	 * Setzt den angegebenen Punkt auf das angegebene Zeichen.
	 */
	void setPoint(CPoint point, char content);

	/**
	 * Gibt die Darstellung aus.
	 */
	void print() const;

	/**
	 * Löscht die Darstellung. Alle Zeichen werden wieder auf
	 * '.' gesetzt.
	 */
	void clear();
};

#endif /* ASCIISCREENSOLUTION_MYCODE_CSCREEN_H_ */

Mann muss die Klasse CScreen selbst machen

Geschrieben von progger am 19.03.2016 um 00:03:

Stimmt der Konstruktor ?

Geschrieben von eulerscheZahl am 19.03.2016 um 06:32:

Nein.
Ich habe jetzt keine Lust, mir das alles in eine compilierfähige Form zusammenzukopieren, aber das ist offensichtlich falsch:

code:

1:
2:
3:
4:
5:
6:
7:
8:
9:

CRectangle::CRectangle(CPoint bottomLeft, CPoint topRight, char fillChar)
{
	if(x.topRight < x.bottomLeft) {
		m_x.bottomLeft = x.bottomLeft;
	}
	if(y.topRight < y.bottomLeft) {
		m_y.bottomLeft = y.bottomLeft;
	}
}

du ignorierst fillChar
Was ist x.topRight? Du meinst wohl topRight.x
Was machst du denn, wenn die Ungleichung nicht erfüllt ist? Dann solltest du die x (bzw. y) Werte tauschen
Was ist mit m_topRight? Das setzt du nirgends.

Geschrieben von progger am 19.03.2016 um 18:39:

Ich habe nicht genau verstanden was ich da bei dem filchar genau beachten soll ?

Vertstehe die Kommentare nicht so ganz

Geschrieben von progger am 21.03.2016 um 10:14:

code:

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:


CRectangle::CRectangle(CPoint bottomLeft, CPoint topRight, char fillChar)
{
       m_topRight= topRight;
	if(x.topRight < x.bottomLeft) {
		m_bottomLeft.x = bottomLeft.x;
	}
if(x.topRight > x.bottomLeft) {
		m_bottomLeft.y = bottomLeft.y;
	}
	if(y.topRight < y.bottomLeft) {
		m_bottomLeft.y = bottomLeft.y;
	}
if(y.topRight > y.bottomLeft) {
		m_bottomLeft.x = bottomLeft.y;
	}

}

So besser ?

m_fillChar = fillchar;

Soll ich das machen für fillchar?

Geschrieben von progger am 21.03.2016 um 10:21:

code:

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

CRectangle::CRectangle(CPoint bottomLeft, CPoint topRight, char fillChar)
{
       m_topRight= topRight;
	if(topRight.x < bottomLeft.x) {
		m_bottomLeft.x = bottomLeft.x;
	}
if(topRight.x > bottomLeft.x) {
		m_bottomLeft.y = bottomLeft.y;
	}
	if(topRight.y < bottomLeft.y) {
		m_bottomLeft.y = bottomLeft.y;
	}
if(topRight.y > bottomLeft.y) {
		m_bottomLeft.x = bottomLeft.y;
	}

}

So besser ?

m_fillChar = fillchar;

Soll ich das machen für fillchar?

Geschrieben von progger am 23.03.2016 um 17:17:

Stimmt es so eulersche zahl ?

Geschrieben von progger am 25.03.2016 um 11:05:

Hat der einzige helfer eulersche zahl auch das forum verlassen ? großes Grinsen

Geschrieben von eulerscheZahl am 25.03.2016 um 11:34:

Nein, ihn hat nur die Motivation verlassen (die Aufgabe ist nicht besonders spannend).

Zitat:

m_fillChar = fillchar;

Ja, beachte aber die Groß-/Kleinschreibung.

Du machst für m_bottomLeft eine Prüfung, m_topRight weist du direkt zu.
Dabei vergisst du den Fall topRight.x == bottomLeft.x.
Was du tun sollst weiß ich nicht, habe den besagten Kommentar nicht gefunden, wenn ein Parameter die Zusicherung verletzt.

Geschrieben von progger am 25.03.2016 um 13:54:

Steht das nicht hier?

Rectangle(CPoint bottomLeft, CPoint topRight, char fillChar = '#');

/**
* Weist den Eigenschaften "linke untere Ecke" und "rechte obere
* Ecke" neue Werte zu.
*
* Vor der Zuweisung wird die Zusicherung überprüft, dass die
* rechte obere Ecke rechts von und oberhalt der linken
* unteren Ecke liegen muss! Ist das nicht der Fall wird keines
* der Attribute verändert.

code:

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

CRectangle::CRectangle(char fillChar)
{
	m_fillChar = fillChar;
}

CRectangle::CRectangle(CPoint bottomLeft, CPoint topRight, char fillChar)
{
	if(x.topRight<x.bottomLeft){

		m_x.bottomLeft = x.bottomLeft;
	}
	if(y.topRight<y.bottomLeft){

			m_y.bottomLeft = y.bottomLeft;
		}
	m_fillChar = fillChar;
}

Geschrieben von eulerscheZahl am 25.03.2016 um 14:46:

Das hatte ich übersehen.
Jetzt fängst du schon wieder mit x.topRight an. Das ist falsch.

Sollte etwa so gehen.

code:
1: 2: 3: 4:	m_bottomLeft.x = min(bottomLeft.x, topRight.x); m_bottomLeft.y = min(bottomLeft.y, topRight.y); m_topRight.x = max(bottomLeft.x, topRight.x); m_topRight.y = max(bottomLeft.y, topRight.y);

offen bleibt, ob man das so setzen darf (x und y könnten ja private sein, habe die Klasse CPoint nicht gefunden).