#include <iostream>
using namespace std;
int main()

{

int breite, hoehe;

cout << "breite? : " << endl;
cin >> breite;

cout << " hoehe? : " << endl;
cin >> hoehe ;

for(int y = 0; y<hoehe; y++)
{
for(int x = 0; x< breite; x++)
{
cout << "X" ;
}
cout << endl;
}

return 0;
}

wenn man hier nun das x++ und y++ in x+2 oder y+2 schreiben will, dann ist das problem, dass der compiler statt die X e die angezeit werden durch 2 teilt, sondern unendl. viele schreibt warum ist das so?

dass der compiler statt die X e die angezeit werden durch 2 teilt, sondern unendl. viele schreibt

Nein, das stimmt nicht. Bzw. sollte er das nicht. Außer die Bedingung wäre kein kleiner gleich, sondern gleich. Dann gäbe es ein Problem. Dein Code, den ich unten noch einmal in Tags gesetzt und leicht abgeändert hinschreibe, funktioniert so wie du es beschrieben hast.

#include <iostream>

int main()
{
	unsigned breite, hoehe;
	if( std::cin >> breite >> hoehe )
		for(unsigned y = 0; y < hoehe ; ++y )
		{
			for(unsigned x = 0; x < breite; ++x )
				std::cout << 'X';
			std::cout << '\n';
		}
}

@h4h0r: Setzen, sechs!

Welcher Knochenfisch wagt es, mich von der Seite anzuquatschen?

Weil "x++" "x=x+1" entspricht. Das ist offensichtlich etwas anderes.

Genau genommen entspricht x=x+1 einem ++x , da der Rückgabewert von x=x+1 schließlich schon um 1 erhöht wurde. x++ exakt auszudrücken ist ein bisschen ekeliger.[/klugscheiß]

x++ exakt auszudrücken ist ein bisschen ekeliger.

++x-1 ?

EDIT:
Da helfen wir uns mit einer Hilfsvariablen var zur Veranschaulichung, SeppJ:

var = ++x; -> x = x+1; var = x;
var = x++; -> var = x; x = x+1;

var = x++; -> var = x; x = x+1;

x = x++;
// =>
x = x; x = x+1;

Erzähl mal, wo die Unterschiede liegen.

x++ exakt auszudrücken ist ein bisschen ekeliger.

++x-1 ?

Dafür müsste der Typ von x Minus unterstützen^* (und (x+1)-1 muss wieder x ergeben⁺), was ja nicht unbedingt gegeben ist, bloß weil der Typ +1 kann.

(Ja, das ist eine faule Ausrede)

^*: Klugscheißergegenbeispiel: Ein forward iterator (der dann aber auch kein +1 kann).
⁺: Klugscheißergegenbeispiel: 9007199254740992.0 (in den üblichen double-Implementierungen)

var = x++; -> var = x; var = x+1;

Das ist kein Zitat weil ich das nie geschrieben habe.

Das ist kein Zitat weil ich das nie geschrieben habe.

Korrigiert. Und nun hör' auf um den heißen Brei herumzureden.

@SeppJ: [&]{ auto x_ = x; ++x; return x_; }()

Edit²:

*: Klugscheißergegenbeispiel: Ein forward iterator (der dann aber auch kein +1 kann).
+: Klugscheißergegenbeispiel: 9007199254740992.0 (in den üblichen double-Implementierungen)

@SeppJ: [&]{ auto x_ = x; ++x; return x_; }()

Das war's was ich ursprünglich mit ekelig meinte.

Arcoth schrieb:

@SeppJ: [&]{ auto x_ = x; ++x; return x_; }()

Das war's was ich ursprünglich mit ekelig meinte.

Ich habe nachgedacht, ob es vielleicht einen dirty-hack in <algorithm> oder <functional> gibt, damit wir Code-Golf spielen können, aber den habe ich schnell aufgegeben.