Forum
 
Fragen
 
Suchen
 
Über Uns
 
 

Programmierung 2 - Seite 3
Neue Frage »

16.09.2017, 01:58 Auf diesen Beitrag antworten »
Victor

Kann ich es in der main etwa so aufbauen?

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:


int main(){


	if( m_topRight == other.m_topRight &&  m_bottomLeft == other.m_bottomLeft &&m_fillChar == other.m_fillChar){

cout << " Rechteck ist gleich " << endl;

}


else{

cout << "false" << endl;






}

Ist das in der Aufgabe gemeint ?
 
 
16.09.2017, 19:05 Auf diesen Beitrag antworten »
as_string

Also erstmal musst Du ja zwei Rechtecke (also Objekte der Klasse CRectangle) anlegen. Davon sehe ich noch nichts.
Dann gibt es die Variablen doch alle in main() gar nicht!
Das was Du geschrieben hast, ist doch die Definition des Operators, wie Du sie schon an zentraler Stelle als Member der Klasse CRectangle gemacht hast. Das machst Du doch logischerweise gerade deshalb, damit Du in der main() das dann nicht mehr machen musst, das ist doch gerade der Witz an der Sache!
Nochmal: Wenn Du eine Klasse schreibst, dann kennst Du deren innerne Aufbau, deren Membervariablen und die Semantik derer. Wenn Du diese kennst und nur wenn Du diese kennst, kannst Du definieren, wann zwei Objekte einer solchen Klasse gleich sind.
In der main() sollst Du gar keine Annahmen über den inneren Aufbau der CRectangle-Objekte machen müssen, Du musst nicht wissen, dass die zwei Ecken und ein Füllzeichen haben und schon gar nicht, wie die entsprechenden Variablen heißen.
Angenommen Du kommst irgendwann auf die Idee zu sagen: Anstelle der beiden Eckpunkte des Rechtecks will ich mir in Zukunft nur noch den Mittelpunkt des Rechtecks und seine Höhe und Breite speichern. Einfach weil ich festgestellt habe im Laufe der Zeit, dass das günstiger ist, weil ich diese Angaben viel häufiger brauche. Zwar kannst Du diese Werte aus den Koordinaten der Eckpunkte ausrechnen und entsprechende Memberfunktionen anbieten, die diese zurück liefern, aber Du musst halt immer rechnen und könntest auch umgekehrt Höhe/Breite und Mittelpunkt Dir direkt merken und aus diesen dann die Eckpunkte ausrechnen, wenn Du diese brauchst (was aber vielleicht seltener der Fall ist). Du könntest die inneren (private-deklarierten) Variablen passend umbauen und müsstest alle Funktionen auch entsprechend anpassen, aber eben nur die Member-Methoden der Klasse, alle Verwender würden davon gar nichts mitbekommen, weil sie ja nur diese Methoden aufrufen.
Das ist natürlich dann auch bei den Operatoren so. Wenn ich andere Variablen habe, muss ich auch diese anpassen. Die Verwendung bleibt aber gleich, Du schreibst einfach:
code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:

int main() {
    CRectangle a(CPoint(5, 5), CPoint(25, 15)), b(CPoint(1, 2), CPoint(3, 4));
    if(a ==b) 
        cout << "Rechtecke gleich" << endl;
    else
        cout << "Rechtecke verschieden" << endl;
    return 0;
}

Aber ich habe wirklich nicht die Erwartung, dass Du jetzt auch irgendwas verstanden hättest... Was soll das alle bringen?

Gruß
Marco
16.09.2017, 20:36 Auf diesen Beitrag antworten »
Victor

Doch ich verstehe was du da geschrieben hast .
Man kann einfach die angelegten Rechtecke a und b einfach mit a==b vergleich und fertig .

Ich habe einfach zu kompliziert gedacht .

Man musste gar nicht die operator == funktion aufrufen .
16.09.2017, 21:44 Auf diesen Beitrag antworten »
as_string

Zitat:
Original von Victor
Man musste gar nicht die operator == funktion aufrufen .

Doch natürlich!!! Das machst Du doch gerade, wenn Du a == b schreibst! Das wäre quasi entsprechend a.operator==(b).

Nochmal: Wenn Du irgendwo sowas wie a == b stehen hast, oder auch a + b etc., und a und/oder b sind keine primitiven Datentypen wie int, double, etc, dann wird der entsprechende operatorXYZ() aufgerufen.

Lerne doch erst solche grundlegenden Dinge, sonst bringt das doch alles nichts!

Gruß
Marco
 Anzeige
 
16.09.2017, 22:22 Auf diesen Beitrag antworten »
Victor

Ah ok .
Jetzt peile ich es .
großes Grinsen

Aber string ich finde dass man um programmieren zu lernen ja auch ein wenig proggen muss.
Ich weiss dir ist es vielleicht leicht gefallen nach Büchern lesen vielleicht zu proggen.

Aber ich kann das Zeug nach dem lesen auch nicht anwenden .

Ich denke ,dass man es durch anwenden lernt .
Ok ich setze mich jetzt an die nächsten Aufgabenteile großes Grinsen
16.09.2017, 22:47 Auf diesen Beitrag antworten »
as_string

Ich meine es ist eher eine Frage der Effizienz. Ich kann auch eine Fremdsprache lernen indem ich einfach dort hin fahre und versuche mit den Leuten zu reden, zuerst mit Händen und Füßen, irgendwann dann ziemlich gebrochen, aber immerhin. Allerdings lernt man auch Fremdsprachen i. A. indem man zuerst eine Menge Vokabeln und Grammatik lernt, bevor man sich versucht mit Leuten zu unterhalten. Manche Dinge wird man sicherlich auch nach vielen Jahren noch falsch machen, wenn man nicht irgendwann auch mal die Grammatik gelernt hat.
Und das funktioniert auch nur, weil es natürliche Sprachen sind. Das alles wird viel schwieriger, wenn es solche Konstrukte wie Programmiersprachen sind. Das lässt sich sicherlich weniger intuitiv erlernen als eine natürliche Sprache.
17.09.2017, 01:24 Auf diesen Beitrag antworten »
Victor

Wie soll das genau jetzt mit der Draw Methode funktionieren ?

Das steht ja in der Header:

* 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;

Auf das Füllzeichen des Rechtecks ?
Ist das die Variable screen oder wie ?

So?

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

void CRectangle::draw(CScreen& screen) const
{
	screen->CScreen::setPoint();
}


Das ist so kompliziert zu verstehen .

Was wollen die genau überhaupt ?
17.09.2017, 11:41 Auf diesen Beitrag antworten »
as_string

Sorry, aber das ist doch völlig hoffnungslos!

Da haben wir jetzt wochenlang über die CRectangle Klasse mit ihren Konstruktoren geschrieben, dabei auch gesehen, dass es verschiedene Konstruktoren gibt, die die Member-Variablen der Klasse belegen, wovon es ganze 3 gibt, zwei Eckpunkte und ein Füllzeichen, und jetzt kommst Du und fragst, was denn das für ein Füllzeichen sein soll??? Und ob die screen-Variable das sein soll, obwohl groß und breit erklärt wird, dass dieses Objekt der Klasse CScreen ist, die verwendet wird, um auf dem Bildschirm (Screen heißt übersetzt Bildschirm!) irgendwelche "Punkte" zu setzen, die aber eigentlich einzelne Zeichen sind.
Dafür gibt es die Methode setPoint in der Klasse, die aber drei Argumente erwartet, wie Du aus dem Klassendiagramm erkennen kannst.
Was Du wieder geschrieben hast hat selbst auch wieder mindestens zwei verschiedene Fehler und eine "Ungewöhnlichkeit", die aber allesamt aufzeigen, dass Du wirklich so absolut noch gar nichts kapiert hast von dem, was wir hier schon seit Wochen versuchen.
Wie kommst Du plötzlich auf "->"? Das hatten wir hier ja noch gar nicht. Weißt Du was dieser Operator bedeutet und was der Unterschied zu einem einzelnen Punkt ist? So etwas lernst Du nicht durchs einfache mal Rumprobieren, sondern indem Du ein Buch zur Hand nimmst (oder Dich im Internet nach C++-Kursen umsiehst, die gibt es da wie Sand am Meer, auch kostenlos).
Warum schreibst Du jetzt wieder CScreen::setPoint??? Das haben wir doch bei einem Aufruf noch nie gemacht. Das Objekt screen ist doch schon von der Klasse CScreen und es ist doch gerade ein zentraler Punkt der Objektorientierten Programmierung, dass ich dann eben die Klasse CScreen bei einem Methodenaufruf nicht mehr explizit benennen muss, weil der Kompiler aufgrund des Objekts das auch selbst ermitteln kann!
Dann steht im Klassendiagramm, dass setPoint zwei Argumente erwartet, Du aber schreibst kein einziges in die Klammern.
Das sind schon drei syntaktische Fehler in einer Zeile.
Dann erst kommt die Semantik. Da hast Du ja überhaupt gar nichts verstanden: Du sollst anhand der Eckpunkte jeden Punkt des Rechtecks ermitteln (in verschachtelten for-Schleifen vielleicht?) und für jeden einzelnen dieser Punkte die Methode setPoint() aufrufen. Aber ich sehe im Moment wirklich keine Chance, wie Du das mit Deinem Wissensstand hinbekommen solltest. Das ist doch einfach utopisch!

Ich will nicht mehr meine Zeit damit vergeuden. Das ganze Unterfangen ist hoffnungslos und frisst nur Deine und meine Zeit auf, ohne irgendwelche Fortschritte. Such Dir endlich ein Buch und lerne wenigstens die Grundlagen, so wie jeder andere, der eine Programmiersprache oder Programmieren im Allgemeinen lernen will!

Gruß
Marco
17.09.2017, 23:03 Auf diesen Beitrag antworten »
Victor

über was soll denn die for schleife gehen?
for (int i =0;i>0;i++)
18.09.2017, 00:31 Auf diesen Beitrag antworten »
as_string

Was soll das für eine for-Schleife sein? Von wo bis wo soll denn i laufen?
Du brauchst zwei ineinander verschachtelte for-Schleifen. Eine für die x-Koordinate und eine für die y-Koordinate. Die x-Koordinate muss vom linken bis zum rechten Rand des Rechtecks laufen, die y-Variable vom unteren Rand zum oberen.

Gruß
Marco
19.09.2017, 09:58 Auf diesen Beitrag antworten »
Victor

Ich weiss das hier meine Idee nicht ganz so richtig ist.
Aber das sind irgendwie die Gedankengänge die ich hier rein geschrieben habe.

Für die X Koordinate muss ich ja die for schleife über die X Werte gehen lassen ,daher habe ich getX genommen.

Aber das zeigt nur Fehler großes Grinsen

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

void CRectangle::draw(CScreen& screen) const
{
	for(int getX() = 0; getX()>0 ; getX()++){


		setPoint(m_x,#);
	}
}



Ich hoffe der Code hat wenigstens bisschen Logik?
19.09.2017, 20:35 Auf diesen Beitrag antworten »
Victor

Kannst du mir noch weiter helfen string ?
Besser bisschen Hilfe von dir als gar keine großes Grinsen
Ohne deine Hilfe schaffe ich gar nichts
20.09.2017, 22:03 Auf diesen Beitrag antworten »
as_string

Das hier:
code: 
1:

for(int getX() = 0; getX()>0 ; getX()++){...}

Ist in so vieler Hinsicht falsch und blödsinnig, dass ich gar nicht weiß, wo ich anfangen soll.
getX() ist doch keine Variable (genauer: kein LValue), der Du eine 0 zuweisen könntest oder die Du eins hochzählen könntest!
Warum sollte die Schleife bei 0 anfangen?
Was sollte die Bedingung ">0" bringen? Das ist beim ersten Durchlauf dann ja nie wahr, wenn Du vorher den Schleifenzähler mit 0 initialisiert hast!

Für mich zeigt das, dass Du noch nicht mal mit so eine grundlegende Sache wie eine for-Schleife auch nicht im Ansatz verstanden hast.
Lass uns deshalb mal anders anfangen. Nehmen wir als Beispiel das Rechteck mit den Ecken (5,5) und (15,25). Um dieses Rechteck zeichnen zu können, müssen wir die Methode setPoint(x, y, c) ja mehrfach aufrufen, und zwar für jeden einzelnen "Punkt" innerhalb dieses Rechtecks.
Wir müssen also z. B. die erste Zeile des Rechtecks zeichnen, indem wir für alle Punkte mit den Koordinaten 5 bis 15 für den x-Wert und 5 für den y-Wert aufrufen.
Also prinzipiell muss das hier ausgeführt werden:
code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

screen.setPoint( 5, 5, '#');
screen.setPoint( 6, 5, '#');
screen.setPoint( 7, 5, '#');
screen.setPoint( 8, 5, '#');
screen.setPoint( 9, 5, '#');
screen.setPoint(10, 5, '#');
screen.setPoint(11, 5, '#');
screen.setPoint(12, 5, '#');
screen.setPoint(13, 5, '#');
screen.setPoint(14, 5, '#');
screen.setPoint(15, 5, '#');

Das würde eine horizontale Linie mit den dem Füllzeichen '#' ausgeben. So könnten wir jetzt Zeile für Zeile weiter machen, also nochmal diese ganzen Anweisungen allerdings mit einer 6 für die y-Koordinate. Und so weiter bis zur 25 in der y-Koordinate.

Das wäre natürlich nicht sehr flexibel, weil man ja für unterschiedliche Rechtecke direkt den kompletten Quellcode ändern müsste. Deshalb wollen wir das mit Schleifen lösen, die flexibel die Anweisungen passend zu den Eckpunkten "generieren".

Deshalb für Dich zuerst mal eine einfache Aufgabe: Schreibe mir einfach mal eine for-Schleife auf für die erste Zeile. Verwende als Laufvariable einfach ein "i" und schreibe die ganzen Zahlen einfach zuerst fix rein. Das können wir dann später noch besser machen. Ich stelle mir also sowas vor:
code: 
1:
2:
3:
4:
5:

for(...) {
    screen.setPoint(i, 5, '#');
}

Was muss in der Klammer hinter "for" statt der Pünktchen stehen, damit i der Reihe nach mit den Zahlen 5 bis 15 belegt wird?

Gruß
Marco
20.09.2017, 22:06 Auf diesen Beitrag antworten »
as_string

Ich habe gerade nochmal die Aufgabe angeschaut. Da ist der zweite Eckpunkt nicht (15,25) sondern (25,15). Das hatte ich falsch in Erinnerung. Das spielt aber letztlich keine wichtige Rolle im Moment. Du kannst meinetwegen den einen oder den anderen nehmen, wie Du möchtest...

Gruß
Marco
22.09.2017, 23:14 Auf diesen Beitrag antworten »
Victor

code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

void CRectangle::draw(CScreen& screen) const
{

	for(int i = 5; 25>=i; i++) {
	    screen.setPoint(i, 5, '#');
	   
	}
  i++;
}


Ich habe am ende noch ein i++ eingebaut ,damit es auch irgendwann eine Zeile höher geht?

Aber das Problem ist ,ich will ja das es irgendwann aufhört oder ?

Irgendwie while Schleife einbauen oder wie?
22.09.2017, 23:50 Auf diesen Beitrag antworten »
as_string

Zitat:
Original von Victor
code: 
1:
2:
3:

	for(int i = 5; 25>=i; i++) {

Nein, das ist schon falsch. Der zweite ist die "condition", aber das ist nicht die Abbruch-Bedingung, sondern eigentlich eine "Weitermach-Bedingung". So lange wie diese "true" ergibt, wird die Schleife fortgesetzt. Du hast es also gerade falsch rum formuliert.
Lies Dir doch am Besten mal das hier durch:
https://www.tutorialspoint.com/cprogramming/c_for_loop.htm
Zitat:
Original von Victor
Ich habe am ende noch ein i++ eingebaut ,damit es auch irgendwann eine Zeile höher geht?

Und was soll das bringen? Dann wird halt am Ende nochmal i hochgezählt. Das wurde innerhalb der Schleife schon von 5 bis 25 hoch gezählt. Wenn Du es noch eins weiter zählst, wird einfach i 26 sein. Es wird mit i aber gar nichts mehr gemacht und deshalb ist das völlig irrelevant.
Aber i ist ja so wie so nicht die Zeilennummer sondern die Spalte. Du willst ja gar nicht i erhöhen sondern Du willst noch eine zweite Variable für die Spalte einführen, also z. B. j. Der Trick ist, dass Du bei screen.setPoint(i, 5, '#'); die 5 ersetzt, z. B. mit einem j.
Dann machst Du um die for-Schleife mit i noch eine weitere for-Schleife außen rum, in der Du das j von 5 bis 15 hoch zählst. Dann hast Du eine innere und eine äußere Schleife und innerhalb der inneren rufst Du screen.setPoint auf. An dieser Stelle hast Du sowohl i als auch j, zuerst wird i und j beide 5 sein. Die innere Schleife zählt i bis 25 hoch. Dann kommt aber wieder die äußere for-Schleife zum Zug und zählt j auf 6 hoch. Mit j=6 wird dann aber i in der inneren wieder neu auf 5 initialisiert und die innere Schleife läuft wieder bis 25 hoch. Jetzt aber wird setPoint mit einer 6 für die y-Koordinate aufgerufen, so dass die zweite Zeile komplett ausgegeben wird. Usw.
Kannst Du das mal probieren?
23.09.2017, 22:50 Auf diesen Beitrag antworten »
Victor

Etwa so String?

code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:


void CRectangle::draw(CScreen& screen) const
{
    for(int j = 5; 15>=j;j++){
	for(int i = 5; 25>=i; i++) {
	    screen.setPoint(i, j, '#');
	    
	}
    }
24.09.2017, 00:01 Auf diesen Beitrag antworten »
as_string

Das sieht doch schon ganz gut aus! Wink

Jetzt haben wir die Koordinaten für die Ecken, also die 5, 25 und die 5, 15 noch hard-coded im Quelltext stehen. Die wollen wir aber aus den Eckpunkten ermitteln!
Also, i ist ja die Zählvariable für die Spalten, also für x. Du muss von der x-Koordinate vom einen CPoint für die linke(-untere) Ecke bis zur x-Koordinate der rechten(-oberen) Ecke laufen für jede Zeile. Du musst also die 5 und die 25 in der inneren for-Schleife entsprechend ersetzen.
Genauso auch in der äußeren for-Schleife die 5 mit dem y-Wert der (linken-)unteren Ecke und die 15 mit der y-Koordinate der (rechten-)oberen Ecke.
Wie kommst Du aber an diese Koordinaten ran? Die Methode ist in der Klasse CRectangle. Du kannst also innerhalb der Klasse direkt auf die jeweiligen Member-Variablen zugreifen. Welches sind denn diese Variablen und wie kommst Du über die Punkte zu den richtigen X/Y-Koordinaten?

Außerdem haben wir auch das Füllzeichen '#' noch hart-kodiert. Auch hierfür haben wir in CRectangle eine Member-Variable, die den richtigen Wert beinhaltet.

Versuch mal, ob Du richtigen Werte für die vier Koordinaten (der beiden Eckpunkte) und das Füllzeichen raus bekommst und an die richtigen Stellen einsetzen kannst.

Gruß
Marco
24.09.2017, 04:07 Auf diesen Beitrag antworten »
Victor

code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:


void CRectangle::draw(CScreen& screen) const
{
    for(int j = 5; 15>=j;j++){
    	screen.CRectangle(i,j,`#´);
	for(int i = 5; 25>=i; i++) {
	    screen.setPoint(i, j, '#');
	    screen.CRectangle(i,j,`#´);


	}
    }
}


Dafür müsste ich doch diesenCRectangle Konstruktor aufrufen siehe meinen Code?
Soll ich auch da Werte reinschreiben?
24.09.2017, 11:40 Auf diesen Beitrag antworten »
as_string

Ohje... das hat doch wirklich keinen Zweck! Ließ endlich mal ein Buch zur Objektorientierten Programmierung! Das macht doch überhaupt gar keinen Sinn das hier mit trial-and-error zu probieren!

Also erstens: ein Konstruktor ist dafür da, ein neues Objekt aufzubauen, Du hast aber schon ein Objekt, sonst könntest Du doch die Methode draw() gar nicht aufrufen, da sie nicht statisch ist!
Dann ruft man doch einen Konstruktor nicht in der Art eines Methodenaufrufs eines Objekts screen einer völlig anderen Klasse auf. Wie kommt man denn nur auf so einen Schwachsinn überhaupt.
Dann hast Du doch gar keinen Konstruktor, der zwei int und ein char akzeptieren würde.
Du hast überhaupt gar keinen blassen Schimmer, was es mit Klassen und Objekten überhaupt auf sich hat und schon gar nicht, weshalb das so ist. Du hast überhaupt keine Vorstellung was Kapselung ist, manchmal denke ich, Dir ist noch nichtmal der Unterschied zwischen Variablen und Methoden richtig klar etc. Du hast Schwierigkeiten grundlegende Konstrukte wie eine for-Schleife zu verwenden. Da schaffst es in eine kurze Programmzeile mehr als 3 Syntaxfehler und ungezählte semantische Fehler einzubauen.

Also das bringt hier wirklich rein gar nichts. Nimm Dir ein Buch. Wenn Du da was nicht verstehst, kannst Du gerne dazu dann fragen, aber das hier ist einfach Zeitverschwendung für alle Beteiligten.

Gruß
Marco
24.09.2017, 13:24 Auf diesen Beitrag antworten »
Victor

Aber wie soll ich den sonst den Konstruktor aufrufen ?

So klappt es auch irgendwie nicht ?

code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:


void CRectangle::draw(CScreen& screen) const
{
    for(int j = 5; 15>=j;j++){
    	CRectangle(i,j,`#´);
	for(int i = 5; 25>=i; i++) {
	    screen.setPoint(i, j, '#');
	    CRectangle(i,j,`#´);


	}
    }
24.09.2017, 13:36 Auf diesen Beitrag antworten »
Victor

Meine andere IDee wäre so ?
Aber funktioniert auch net

code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:


void CRectangle::draw(CScreen& screen) const
{
    for(int j = 5; 15>=j;j++){
    	this->CRectangle(CPoint i,Cpoint j , `#´);
	for(int i = 5; 25>=i; i++) {
	    screen.setPoint(i, j, '#');
	    this->CRectangle(CPoint i,Cpoint j , `#´);


	}
    }
24.09.2017, 16:09 Auf diesen Beitrag antworten »
Victor

Sind meine Idee wieder nicht gut ?
Ich möchte aber wissen wie es geht großes Grinsen

Habe im Netz herum gegoogelt .

Es steht teilweise drinnen das man Konstruktor in Funktionen mit this aufrufen kann ?

Aber das gibt ja trotzdem Fehler bei Eclipse
24.09.2017, 21:24 Auf diesen Beitrag antworten »
as_string

Wieso um alles in der Welt willst Du einen Konstruktor aufrufen??? Ich hab doch schon erklärt dass das Schwachsinn an dieser Stelle ist!
24.09.2017, 22:03 Auf diesen Beitrag antworten »
Victor

Wie soll ich das dann hier machen ?

Wie kommst Du aber an diese Koordinaten ran? Die Methode ist in der Klasse CRectangle. Du kannst also innerhalb der Klasse direkt auf die jeweiligen Member-Variablen zugreifen. Welches sind denn diese Variablen und wie kommst Du über die Punkte zu den richtigen X/Y-Koordinaten?
24.09.2017, 23:34 Auf diesen Beitrag antworten »
as_string

Welche Membervariablen hat denn die Klasse CRectangle?
25.09.2017, 06:02 Auf diesen Beitrag antworten »
Victor

Meinst du das ich die get Methoden bottomLeftCorner und getTopRoght aufrufen soll ?
25.09.2017, 10:39 Auf diesen Beitrag antworten »
as_string

Du kannst die Methoden aufrufen und das könnte i. A. sogar vorteilhaft sein, aber in diesem Fall könntest Du auch einfach direkt auf die Membervariablen zugreifen.
Nochmal: Was sind denn die drei Membervariablen der Klasse CRectangle? Tipp: Schau doch mal in die dazugehörige Headerdatei. Dort sind die deklariert. Und noch ein Tipp: Um Membervariablen von anderen (z. B. lokalen/auto Variablen innerhalb einer Methode) unterscheiden zu können, wird in Deinen Beispielen offenbar die Konvention benutzt, vor Membervariablen ein "m_" zu schreiben ("m" wie "member").

Gruß
Marco

PS: Warum kannst Du eigentlich nicht einfach mal machen, was ich sage? Ich hatte nach den Membervariablen gefragt und Du schreibst dann was von gettern. Warum kannst Du dann nicht einfach auch mal die Membervariablen nennen? Wenn Du nicht weißt, was eine Membervariable ist, dann frag das nach. Wenn sonst was an meiner Frage unklar ist bitte auch. Aber ignorier doch nicht ständig was ich schreibe und komme mit etwas ganz anderem! Ich versteh Dich einfach nicht...
25.09.2017, 13:29 Auf diesen Beitrag antworten »
Victor

Ah die Variablen

m_bottomLeft;


m_topRight;


m_fillChar

Aber wie soll ich die jetzt genau im Code einbauen verwirrt
Komme irgendwie nicht auf die Idee großes Grinsen
25.09.2017, 14:03 Auf diesen Beitrag antworten »
Victor

Soll ich jetzt die Zahlen in der for Schleife irgendwie mit den Member Variablen ersetzen?
25.09.2017, 15:34 Auf diesen Beitrag antworten »
as_string

Ja, mehr oder weniger schon. Allerdings brauchst Du für die for-Schleifen ja wirklich Koordinatenwerte, also int-Zahlen. Die Member m_bottomLeft und m_topRight sind aber Objekte der Klasse CPoint, also keine int-Zahlen.
Um an die jeweilgen Koordinaten der Punkte zu kommen musst Du dann jeweils getX() bzw getY() aufrufen.

Das Füllzeichen hast Du direkt als char in der Member-Variable m_fillchar und kannst das für den setPoint-Aufruf direkt verwenden.

Versuche das mal.

Gruß
Marco
25.09.2017, 17:00 Auf diesen Beitrag antworten »
Victor

Puuh bin irgendwie so überlastet .
Bei meinen Ideen werden nur fehler amgezeigt

for(int j = 5; 15>=j;j++){
screen.getX();
Vor dem getX muss ich doch irgendwas schreiben oder ?

Ich dachte screen ,aber nur Fehler .
Verdammt
25.09.2017, 17:23 Auf diesen Beitrag antworten »
as_string

Warum screen.getX()? Du willst doch nicht die x-Koordinate von screen (was auch immer das sein sollte, macht ja gar keinen Sinn) sondern von der jeweiligen Ecke haben. Deshalb fragte ich Dich doch nach den Membervariablen, weil zwei davon die beiden Eckpunkte repräsentieren. Von denen willst Du die X- und Y-Werte haben!
Warum an dieser Stelle? Schau doch mal: Die Laufvariable j der äußeren for-Schleife wird doch in der setPoint()-Methode für die Y-Koordinate des zu setzenden Punktes verwendet. Diese soll doch zwischen der Y-Koordinate des unteren Eckpunkts und der des oberen Eckpunkts laufen.
Du sollst also die 5 und die 15 von der äußeren for-Schleife durch die jeweiligen y-Koordinaten-Werte der beiden Eckpunkte ersetzen.
Genau so sollst Du in der inneren for-Schleife die Werte 5 und 25 des minimalen und maximalen X-Wertes durch die X-Koordinaten der beiden Eckpunkte ersetzen.

Nochmal: Wie kommst Du z. B. an die y-Koordinate des Eckpunktes unten-links?

Gruß
Marco
25.09.2017, 18:23 Auf diesen Beitrag antworten »
Victor

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


void CRectangle::draw(CScreen& screen) const
{
    for(int j = m_topRight.getX(); m_topRight.getX()>=j;j++){

	for(int i = m_bottomLeft.getY();  m_bottomLeft.getY()>=i; i++) {
	    screen.setPoint(m_topRight,m_bottomLeft,´#`);




	}
    }
}


hmm irgendwas passt immer noch nicht?
25.09.2017, 21:42 Auf diesen Beitrag antworten »
as_string

Ja, ich weiß auch nicht... warum ersetzt Du jetzt denn i und j im Aufruf von setPoint()?
Weißt Du immer noch nicht, wie eine for-Schleife funktioniert?
Vorher stand in der ersten for Klammer noch 5 und 15, jetzt hast Du bei beiden denselben Wert rein geschrieben. Das muss doch auch Dir auffallen, dass da was nicht stimmt, oder?
Für welche Werte standen denn die 5 und die 15 oder die 5 und die 25? Welche Koordinaten von welchen Punkten waren das denn? Ich hab’s doch sogar schon geschrieben gehabt.

Sag mal ehrlich: verstehst Du überhaupt irgendetwas von dem allem hier? Ich schreib doch wirklich schon in einer Art, dass es selbst jemand ganz ohne Vorwissen irgendwie verstehen sollte, aber bei Dir habe ich ehrlich nicht den Eindruck. Du rätst einfach nur die ganze Zeit rum. Das bringt doch einfach rein gar nichts!
26.09.2017, 01:06 Auf diesen Beitrag antworten »
Victor

code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:


void CRectangle::draw(CScreen& screen) const
{
    for(int j = m_topRight.getX(); m_topRight.getX()>=j;j++){

	for(int i = m_bottomLeft.getY();  m_bottomLeft.getY()>=i; i++) {
	    screen.setPoint(j , i,´#`);   hier meckert er ?




	}
    }
}


Ist das bisschen besser ?
26.09.2017, 07:48 Auf diesen Beitrag antworten »
as_string

Ich weiß nicht, warum Du die Bedeutung von i und j jetzt vertauscht hast, vorher hatten wir i für die x-Koordinate und j für y, aber das macht im Prinzip nichts.
Aber immernoch hast Du für die Schleifen jeweils dieselbe Zahl für Anfang und Ende. Das kann doch nicht stimmen! Bei welcher x-Koordinate von welchem Punkt muss die erste Schleife anfangen? Von welchem Punkt muss die x-Koordinate sein, bei dem sie aufhört, das kann doch nicht derselbe Punkt sein! Genauso für die beiden y-Koordinaten. Versuche doch mal zu verstehen, was wir hier überhaupt tun!
Der Fehler, den ich sehe, sind einfach die Anführungszeichen um das Füllzeichen. Die sind bei Dir irgendwie krumm... das müssen gerade Hochkommata sein, so wie wir es auch die ganze Zeit vorher hatten.
Aber eigentlich sollst Du ja auch das hier fest angegebene Füllzeichen durch den Wert einer weiteren Membervariable ersetzen. Was musst Du hier noch machen?
26.09.2017, 10:14 Auf diesen Beitrag antworten »
Victor

die erste Vorschleife muss doch bei der x Koordinate beginnen ,wie du gesagt hast oder ?

Also getX()
Daher habe ich das geschrieben :

for(int j = m_topRight.getX(); m_topRight.getX()>=j;j++)

Ist das überhaupt richtig ?
Vielleicht gehen wir Schritt für Schritt vor.
Ich weiss es ist für dich leider mühsam ,aber mir fällt das einfach sau schwer.
Was soll ich machen.
26.09.2017, 11:47 Auf diesen Beitrag antworten »
as_string

Die X Koordinate doch aber nicht zweimal von demselben Punkt! Das wäre dann ja immer nur ein und derselbe Wert, wie willst Du dann eine komplett Zeile bekommen. Also: nicht zweimal topRight, sondern einmal bottomLeft und einem topRight!

Gruß
Marco
26.09.2017, 12:27 Auf diesen Beitrag antworten »
Victor

Bin irgendwie gerade verwirrt ,warum bei mir im Code 2 mal der gleiche Wert aufgerufen wird .

Liegt wohl daran ,dass ich nicht so fit bin beim proggen großes Grinsen

So sah der code ja mal aus:

code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

void CRectangle::draw(CScreen& screen) const
{
    for(int j = 5; 15>=j;j++){
	for(int i = 5; 25>=i; i++) {
	    screen.setPoint(i, j, '#');
	    
	}
    }



code: 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

void CRectangle::draw(CScreen& screen) const
{
    for(int j =m_topRight.getX() ; 15>=j;j++){
	for(int i =m_bottomLeft.getY() ; 25>=i; i++) {
	    screen.setPoint(i, j, '#');
	    
	}
    }


Ich denke das du meinst ,dass ich nicht zweimal topRight und bottomLeft in der for Schleife schreiben soll?
vorherige Seite
nächste Seite
 
Neue Frage »
Antworten »


Verwandte Themen

Die Beliebtesten »
Die Größten »
Die Neuesten »


Informatiker Board » Themengebiete » Praktische Informatik » Programmierung 2

 
© 2005-2019 bei Informatikerboard.de | Archiv, alt, neueste | Kontakt | Jugendschutz | Nutzungsbedingungen