Ich wollte folgendes Programmieren:

Man gibt eine Zahl zwischen 0 und 250 ein und eine andere zwischen 251 und 500.
Wenn man z. B. bei der ersten Zahl 17 eingibt, soll von 17 aus bis 250 gezählt werden. Das gleiche bei der Zahl 2 bis 500. Beide Aufwärtszähler sollen unabhängig voneinander und nebeneinander hochzählen.

Bsp:

Zahl 1: 144 Zahl 2: 499
Zahl 1: 145 Zahl 2: 500
Zahl 1: 146
Zahl 1: 147
Zahl 1: 148
[...]
Zahl 1: 249
Zahl 1: 250

Wenn man jedoch bei der Zahl 1 eine Zahl > 250 oder bei Zahl 2 eine Zahl < als 251 eingibt, soll eine Fehlermeldung ausgegeben werden.

Folgenden Code habe ich aufgesetzt:

#include <iostream>
using namespace std;

int main()
{
   float Zahl1, Zahl 2;

   cout << endl;
   cout << "Geben Sie zwei Zahlen ein!" << endl;
   cout << "Zahl 1: ";
   cin  >> Zahl1;
   cout << "Zahl 2: ";
   cin  >> Zahl2;
   cout << endl;

   if (((Zahl1>=0)&&(Zahl1<=250))&&((Zahl2>=251)&&(Zahl2<=500)))
   {
     for(Zahl1=Zahl1, Zahl2=Zahl2; Zahl1<=250, Zahl2<=500; Zahl1++, Zahl2++)
     {
       cout << "Zahl 1: " << Zahl1 << "Zahl 2: " << Zahl2 << endl
     }
   }
   else (((Zahl1>=250)&&(Zahl1<=500))||((Zahl2>=0)&&(Zahl2<=250)))
   {
     cout << "Error!" << endl;
   } 

   return 0;
}

Bei mir klappt es jedoch nicht.

Wenn ich z. B. bei Zahl1 10 eingebe und bei Zahl2 0, dann zählt Zahl1 bis 260.

Beispiel:

Zahl 1 = 10 Zahl 2 = 0
Zahl 1 = 11 Zahl 2 = 1
Zahl 1 = 12 Zahl 2 = 2
[...]
Zahl 1 = 259 Zahl 2 = 499
Zahl 1 = 260 Zahl 2 = 500

Das will ich nicht. Zahl1 soll bei 250 aufhören, während Zahl2 bis 500 fertig zählt.

Hätte jemand von euch einen Vorschlag, wie ich das Lösen kann?

Vielen Dank für die Antworten im Voraus.

Gruß

Max

das Komma in der Bedingung deiner for-Schleife ist der Fehler:

Zahl1<=250, Zahl2<=500

Ersetze es durch den passenden logischen Operator (&& oder ||), je nachdem wie die Aufgabenstellung zu verstehen ist...

P.S: Wenn du innerhalb der Schleife nur je eine Zahl weiterzählen lassen willst (wenn die andere schon die Grenze erreicht hat), dann mußt du das Inkrementieren mit einer if-Anweisung verknüpfen (anstatt stumpf in der for-Schleife immer hochzuzählen).

Hier hattest du Glück, dass das Problem immer noch erkennbar war. Oder war es das? Vielleicht hat Th69 ja auch ein ganz anderes Problem gelöst, welches gar nicht in deinem eigentlichen Code zu finden ist und dein eigentliches Problem ist beim Abschreiben verschwunden. Dann hättest du seine Zeit verschwendet.

#include <iostream>
#include <utility>
#include <limits>

int main()
{
        unsigned short first, second;
        for(;;)
        {
                std::cout << "Zahl1: ";
                std::cin >> first;
                std::cout << "Zahl2: ";
                std::cin >> second;

                if(!std::cin.good()) ///Wenn wegen irgend einem Scheiß ein Fehlerbit gesetzt wurde (bspw. jemand gibt "a" ein)...
                {
                        std::cin.clear();///Fehlerstatus zurücksetzen
                        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');///Ignoriere *alle* Zeichen bis zum nächsten newline
                        std::cout << "\nJetz ma ehrlich....\n";///Dem Idioten die Meinung sagen
                        continue;/// Nochmal von vorne...
                }

                if(first > 250 //Prüfen, ob die Zahlen im falschen Bereich liegen
                or second < 251
                or second > 500)
                        std::cout << "Nein!\n";///Evt. (wenn du es kannst) mit exceptions
        }
}

Das sieht irre aus ...

Das hast du schön erkannt, dass dein Code irre ist. Er löst noch nicht einmal die Aufgabenstellung, löst stattdessen ein Problem, welches hier überhaupt nicht gefragt war, zudem auch noch suboptimal und trägt somit überhaupt nichts zum Thread bei, außer beleidigen und angeben zu wollen.

Zudem wäre ein Komplettlösung hier wohl ohnehin didaktisch falsch, auch wenn es einigen wahrscheinlich in den Fingern juckt.

Sone schrieb:

Zudem wäre ein Komplettlösung hier wohl ohnehin didaktisch falsch, auch wenn es einigen wahrscheinlich in den Fingern juckt.

Da du Sone schon das vierte Mal innerhalb einer kurzen Zeitspanne beleidigst, kann ich nur daraus schließen dass du ihn loswerden willst. Wenn du das willst, dann verbanne ihn einfach, anstatt nutzlose Postings zu fabrizieren.

,

oder

&&

willst.

Das Komma macht nicht das was du meinst.

(Außerdem, was verstehst du unter unabhängig (Na gut, mit Threads will ich dich jetzt nicht plagen. ))

Die ganzen Klammern sind unnoetig:

if (Zahl1>=0 && Zahl1<=250 && Zahl2>=251 && Zahl2<=500)

Sie sind aber auch kein Fehler. In deinem Fall tragen sie aber nicht unbedingt zur Uebersichtlichkeit bei, finde ich ...

Was haben diese Anweisungen im for-Kopf fuer einen Sinn?

Zahl1=Zahl1, Zahl2=Zahl2

Der Komma-Operator dient dazu mehrere Ausdruecke von links nach rechts auszuwerten, wobei nur das Ergebnis des letzten Ausdrucks zurueckgegeben wird, also durch

Zahl1<=250, Zahl2<=500

pruefst du eigenntlich nur Zahl<=500

Der zusaetzliche Ausdruck nach else hat hier gar nichts zu suchen, ich schaetze mal du hast im Original Code ein else if stehen. Wie auch immer - das ist gar nicht noetig. else heisst einfach "was anderes" und reicht allein vollkommen aus (du moechtest ja eine Fehlermeldung ausgeben, wenn der Benutzer was anderes eingegeben hat.

Die for-Schleife, die du benutzt kann so gar nicht zur Loesung fuehren. Ich wuerde eine einfache while Schleife benutzen un darin nur pruefen, ob sich einer der Zahlen noch im gueltigen Bereich befindet. Den Rest wuerde ich in der Schleife machen.

Hier mein Loesungsvorschlag zum selberbasteln:
Solange sich einer der Zahlen im gueltigen Bereich befindet: gib Zahl1 aus und erhoehe sie, wenn sich Zahl1 noch im gueltigen Bereich findet; Dasselbe fuer Zahl2

for(Zahl1=Zahl1; Zahl1<=250; Zahl1++)
{
  cout << "Zahl1: " << Zahl1 << endl;
}

for(Zahl2=Zahl2; Zahl2<=500; Zahl2++)
{
  cout << "Zahl2: " << Zahl2 << endl;
}

Zumindest zählen jetzt beide unabhängig voneinander.

Ich weiß aber immer noch nicht, wie ich die beiden Zahlen, also Zahl1 und Zahl2, nebeneinander bringen kann.

Ist eigentlich dafür eine For - Schleife geeignet?

@Ferris:

Zahl1=Zahl1, Zahl2=Zahl2

Das soll einfach den folgenden Sinn haben:
Zahl1 soll von x bis 250 und Zahl2 soll von y bis 500 zählen.

Der Grundgedanke war einfach der, die beiden Zahlen nebeneinander und unabhängig voneinander hochzählen zu lassen.

Bsp:

Zahl1: 140 Zahl2: 354
Zahl1: 141 Zahl2: 355
Zahl1: 142 Zahl2: 356
Zahl1: 143 Zahl2: 357
[...]
Zahl1: 250 Zahl2: 500

Mehr wollte ich gar nicht.

@afasdfasf

Ich hoffe, dass ich niemanden dazu genötigt habe, mich zu verbannen??????

Zahl1=Zahl1, Zahl2=Zahl2

Das soll einfach den folgenden Sinn haben:
Zahl1 soll von x bis 250 und Zahl2 soll von y bis 500 zählen.

Eine Selbstzuweisung ist immer Schwachsinn.
Außer man treibt Spielchen mit Klassen, die im Zuweisungs-Operator irgendwelchen Blödsinn stehen haben (was aber schlechtes "Design" ist, oder wie man spezifisch das nennt).

silent_max schrieb:

Der Grundgedanke war einfach der, die beiden Zahlen nebeneinander und unabhängig voneinander hochzählen zu lassen.

Bsp:

Zahl1: 140 Zahl2: 354
Zahl1: 141 Zahl2: 355
Zahl1: 142 Zahl2: 356
Zahl1: 143 Zahl2: 357
[...]
Zahl1: 250 Zahl2: 500

Mehr wollte ich gar nicht.

Und wieso nicht

for(; Zahl1 <= 250 && Zahl2 <= 500; ++Zahl2, ++Zahl1)
  cout << "Zahl1: " << Zahl1 << " Zahl2: " << Zahl2 << endl;

?
Falls eine der beiden Zahlen nicht "bis zum Ende kommt", dann schreib das rein - lässt sich leicht lösen.

Ich hoffe, dass ich niemanden dazu genötigt habe, mich zu verbannen??????

Näh, du hast doch keine Scheiße gebaut. Ich wurde doch mit gutem Grund gebannt (wie lang eigentlich?).

while (Zahl1 <= 250 || Zahl2 <= 500)
{
	if (Zahl1 <= 250)
		std::cout << "Zahl1:\t" << Zahl1++ << "\t";
	else
		std::cout << "\t\t";

	if (Zahl2 <= 500)
		std::cout << "Zahl2:\t" << Zahl2++;

	std::cout << std::endl;
}