= sagt wenn der rechte wert gößer oder gleich so groß ist wie der linke, dann ...
== sagt, wenn der linke wert genau so groß ist wie der rechte, dann ...

Hoffe diese kleine Einführung hat dein Problem gelöst und eventuell deine Programmierkenntnisse etwas erweitert.

Gruß
MWJK

in einer if-Abfrage gibt es mehrere Varianten Zahlen zu vergleichen.
einmal "<", was sagt wenn der linke wert kleiner ist als der rechte, dann ...
das gegenteil ist ">" dieses, was sagt wenn der rechte wert kleiner ist als der linke, dann ...
wenn du gleiche werte hast kommst du damit nicht weit.
dafür gibt es folgende möglichkeiten:
<= sagt wenn der linke wert kleiner oder gleich so groß ist wie der rechte, dann ....

= sagt wenn der rechte wert gößer oder gleich so groß ist wie der linke, dann ...
== sagt, wenn der linke wert genau so groß ist wie der rechte, dann ...

Hoffe diese kleine Einführung hat dein Problem gelöst und eventuell deine Programmierkenntnisse etwas erweitert.

Gruß
MWJK

Das weis ich schon...sonst hätte ich if ja auch gar nicht anwenden können.

Mein Problem ist, das der Benutzer bis zu 30 Zahlen eingeben kann und davon soll das Programm dann einmal die höchste und einmal die niedrigste ermitteln.

Das hab ich dann so gelöst(das ist jetzt nur für eine Zahl, also bsp.):

if ((Zahl1 > Zahl2) && (Zahl1 > Zahl3) && (Zahl1 > Zahl4) && (Zahl1 > Zahl5)
&& (Zahl1 > Zahl6) && (Zahl1 > Zahl7) && (Zahl1 > Zahl8) && (Zahl1 > Zahl9)
&& (Zahl1 > Zahl10) && (Zahl1 > Zahl11) && (Zahl1 > Zahl12) && (Zahl1 > Zahl13)
&& (Zahl1 > Zahl14) && (Zahl1 > Zahl15) && (Zahl1 > Zahl16) && (Zahl1 > Zahl17)
&& (Zahl1 > Zahl18) && (Zahl1 > Zahl19) && (Zahl1 > Zahl20) && (Zahl1 > Zahl21)
&& (Zahl1 > Zahl22) && (Zahl1 > Zahl23) && (Zahl1 > Zahl24) && (Zahl1 > Zahl25)
&& (Zahl1 > Zahl26) && (Zahl1 > Zahl27) && (Zahl1 > Zahl28) && (Zahl1 > Zahl29)
&& (Zahl1 > Zahl30))
{
Label1->Caption = String (Zahl1);
}

Das funktioniert auch ziemlich gut, aber sobald der benutzer die kleinste/größte Zahl mehrfach ein gibt, wirt kein ergebniss mehr angezeigt.

Ich hoffe, das ich es jetzt besser beschrieben habe

Gruß
MWJK

Achso, das macht das Problem etwas klarer.
Verwende doch bei sowas einfach eine For-Schleife.
Müssen dort 30 Zahlen eingegeben werden, oder wie hattest du das vor?
Oder wieviele zahlen? und was benutzt du, dass die eingegeben werden können?

Gruß
MWJK

For-Schleife? Gut, da muss ich mich erst noch ein wenig informieren

Also 3 Zahlen müssen eingegeben werden und ab dann kann man wie man lustig ist bis zu 30 Zahlen eingeben.
Für die eingabe benutz ich ein Edit.

Was weisst du über For-Schleifen noch nicht? Stelle deine Fragen und ich werde Sie nach meinem besten Wissen beantworten und die anderen User hier sicher auch.

Gruß
MWJK

Also hast du 30 Edits auf deiner Form, von denen mindestens 3 gefüllt sein müssen?

Was weisst du über For-Schleifen noch nicht? Stelle deine Fragen und ich werde Sie nach meinem besten Wissen beantworten und die anderen User hier sicher auch.

Gruß
MWJK

nee nee, ich hab nur ein Edit, das nach jeder eingabe geleert wirt. Die Eingabe wirt dann über jeweils eine Variable vermerkt.

Also ehrlich gesagt, wusste ich über For-Schleifen noch gar nichts, aber ich hab mich jetzt ein wenig informiert. Hat sich ziemlich kompliziert angehört, aber bis jetzt hab ich nur eine Frage.
Kann man die Schleife nur vorwärts laufen lassen, oder geht es auch rückwärts?
Ansonsten hat mich das, was ich über die For-Schleife gelesen habe, auf ne neue idee gebracht.

Ich werd das jetzt alles erstmal ausprobieren und schreib dann noch mal wenn ich nicht klar komm.

Und übrigens, danke ^_

Wenn du willst kann ich dir gleich einen Quelltext schicken zu dem Programm, das du haben wolltest. Realisiert nicht nur mit if sondern auch mit for-schleifen.

Gruß
MWJK

Also, eine Schleife läuft in eine Richtung und kann bei belieben abgebrochen werden.

Wenn du willst kann ich dir gleich einen Quelltext schicken zu dem Programm, das du haben wolltest. Realisiert nicht nur mit if sondern auch mit for-schleifen.

Gruß
MWJK

nee danke. Ich will nicht undankbar wirken, aber so lange für mich ne changs besteht, das mir solche erklärungen wie bisher reichen, möchte ich sowas nicht. ^_

Aber ich hab noch ne frage.

Ist es möglich für die Bedingung einer For-Schleife mehrere if-sätze(hat bestimmt auch nen richtigen namen ^_) zu benutzen?

Also ungefähr so:

for (...; if (...)..., if (...)...;...)

du legst eine for-schleife folgendermaßen an:

for(int c = 0; c <= 30; c = c + 1){
//Deine Anweisungen
}

Somit läuft die Schleife 31 mal durch (fängt bei 0 an, wird bis 30 hochgezählt und wenn es auf 30 steht nochmal) statt c = c + 1 kannst du auch c++ schreiben.

wenn du jetz mehrere kriterien eingibst brauchst du ja auch mehrere variablen. dafür ist wahrscheinlich eine while-schleife besser.
Eine solche legst du folgendermaßen an:

//Variablen die du haben willst
while(/*Kriterium wie lange die schleife laufen soll*/){
//Anweisungen was getan werden soll
//Hochzählen, sonstiges auf dass deine Kriterien irgendwann erfüllt werden
}

Gruß
MWJK

Kann sein, das ich über die For-Schleife ws falsch verstanden habe, aber so wie ich das verstanden hab, wird in diesem Fall:

for(int c = 0; c <= 30; c = c + 1)

die For-Schleife sofort abgebrochen, da als Bedingung gesetzt ist, das der richtige wert kleiner oder gleich dreißig ist. Und null ist ja kleiner als 30, also müsste es ja abgebrochewn werden. Und es vergleicht ja auch nicht die eingegebenen Zahlen.

Ich hätte mir das so vorgestellt, dass ab null angefangen wird hoch zu zählen und jedes mal nachdem 1 dazu gezählt wurde, überprüft wird, ob der Wert der For-Schleife bereits mit einen der eingegebenen Zahlen übereinstimmt.
Und dadurch, das gleich nachdem ersten übereinstimmenden Wert abgebrochen wird, stört es nicht, wenn ein wert mehrfach vorhanden ist. und für die höchste zahl wäre es dann umgedreht.

Ich glaube, da ist ne while-Schleife genau das richtige.
Ich werde es mal ausprobieren.

Kann sein, das ich über die For-Schleife ws falsch verstanden habe, aber so wie ich das verstanden hab, wird in diesem Fall:

for(int c = 0; c <= 30; c = c + 1)

die For-Schleife sofort abgebrochen, da als Bedingung gesetzt ist, das der richtige wert kleiner oder gleich dreißig ist. Und null ist ja kleiner als 30, also müsste es ja abgebrochewn werden.

Verkehrt, das bedeutet nur, dass die for-schleife solange ausgeführt wird, solange c kleiner als 30 ist (oder eben gleich groß).
das heisst die for-schleife wird 31 mal ausgeführt.

Gruß
MWJK

aufjedenfall hab ich mein Problem jetzt gelöst....Wenn auch ziemlich unelegant ^_

Dieses hab ich jetzt für die niedrigste zahl genommen und es funktioniert einwandfrei. Das selbe werde ich jetzt noch für die höchste Zahl machen.

void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
  R = R + 1;
  if (Zahl1 == R) {nAlter->Caption = String (Zahl1);Timer1->Enabled = false;}
  if (Zahl2 == R) {nAlter->Caption = String (Zahl2);Timer1->Enabled = false;}
  if (Zahl3 == R) {nAlter->Caption = String (Zahl3);Timer1->Enabled = false;}
  if (Zahl4 == R) {nAlter->Caption = String (Zahl4);Timer1->Enabled = false;}
  if (Zahl5 == R) {nAlter->Caption = String (Zahl5);Timer1->Enabled = false;}
  if (Zahl6 == R) {nAlter->Caption = String (Zahl6);Timer1->Enabled = false;}
  if (Zahl7 == R) {nAlter->Caption = String (Zahl7);Timer1->Enabled = false;}
  if (Zahl8 == R) {nAlter->Caption = String (Zahl8);Timer1->Enabled = false;}
  if (Zahl9 == R) {nAlter->Caption = String (Zahl9);Timer1->Enabled = false;}
  if (Zahl10 == R) {nAlter->Caption = String (Zahl10);Timer1->Enabled = false;}
  if (Zahl11 == R) {nAlter->Caption = String (Zahl11);Timer1->Enabled = false;}
  if (Zahl12 == R) {nAlter->Caption = String (Zahl12);Timer1->Enabled = false;}
  if (Zahl13 == R) {nAlter->Caption = String (Zahl13);Timer1->Enabled = false;}
  if (Zahl14 == R) {nAlter->Caption = String (Zahl14);Timer1->Enabled = false;}
  if (Zahl15 == R) {nAlter->Caption = String (Zahl15);Timer1->Enabled = false;}
  if (Zahl16 == R) {nAlter->Caption = String (Zahl16);Timer1->Enabled = false;}
  if (Zahl17 == R) {nAlter->Caption = String (Zahl17);Timer1->Enabled = false;}
  if (Zahl18 == R) {nAlter->Caption = String (Zahl18);Timer1->Enabled = false;}
  if (Zahl19 == R) {nAlter->Caption = String (Zahl19);Timer1->Enabled = false;}
  if (Zahl20 == R) {nAlter->Caption = String (Zahl20);Timer1->Enabled = false;}
  if (Zahl21 == R) {nAlter->Caption = String (Zahl21);Timer1->Enabled = false;}
  if (Zahl22 == R) {nAlter->Caption = String (Zahl22);Timer1->Enabled = false;}
  if (Zahl23 == R) {nAlter->Caption = String (Zahl23);Timer1->Enabled = false;}
  if (Zahl24 == R) {nAlter->Caption = String (Zahl24);Timer1->Enabled = false;}
  if (Zahl25 == R) {nAlter->Caption = String (Zahl25);Timer1->Enabled = false;}
  if (Zahl26 == R) {nAlter->Caption = String (Zahl26);Timer1->Enabled = false;}
  if (Zahl27 == R) {nAlter->Caption = String (Zahl27);Timer1->Enabled = false;}
  if (Zahl28 == R) {nAlter->Caption = String (Zahl28);Timer1->Enabled = false;}
  if (Zahl29 == R) {nAlter->Caption = String (Zahl29);Timer1->Enabled = false;}
  if (Zahl30 == R) {nAlter->Caption = String (Zahl30);Timer1->Enabled = false;}

}

machs doch so:

//global:
int Zahl[30];

for(int S = 0; S <= 30; S++){
   for(int R = 0; R <= 30; R++){
      if (Zahl[S] == R) {
         nAlter->Caption = String (Zahl[S]);R = 30; S = 30;
      } 
   }
}

das ist das gleiche nur etwas eleganter gelöst, ohne Timer.

Gruß
MWJK

int Zahl[29];

// array mit den Zahlen füllen, wie auch immer. 

//-------------
int MIN = Zahl[0];
int MAX = 0;

for(int i = 0; i < 29; i++)
   {
      if(Zahl[i] > MAX) MAX = Zahl[i];
      if(Zahl[i] < MIN) MIN = Zahl[i];
   }
ShowMessage("höchste Zahl = " + IntToStr(MAX) + "\nniedrigste Zahl = " + IntToStr(MIN));

PS: Außerdem empfehle ich mal die STL-Algorithmen min_element() und max_element().

1 bis 30 sind 30 und 0 bis 29 ist bei mir auch 30, aber vielleicht lernt man ja heute etwas anderes in der Schule

Ja richtig, aber bei der Array-Dimension gibst du die Anzahl der Elemente an und nicht den maximal möglichen Index - und ein "int zahl[29];" hat 29 Elemente, die von "zahl[0]" bis "zahl[28]" angesprochen werden.

"min_element() und max_element()" man kan es auch komplizierter machen als es ist.

Was ist daran kompliziert? Solange ich meinen Code nicht bis zum Ende ausoptimieren muß, nehme ich lieber STL-Möglichkeiten als sie von Hand nachzubauen.

Aber das muß jeder selber wissen, viele Wege führen nach Rom. Abgesehen davon hatte ich geschrieben, daß ich es so oder so ähnlich machen würde und ist wohl gegenüber dem 'Maraton' code eine Verbesserung.

Ja, das ist er auf jeden Fall (aber es gibt ja auch kaum eine Möglichkeit, es noch schlechter zu machen :D)

int max = *max_element(Zahl, Zahl+29);

1 bis 30 sind 30 und 0 bis 29 ist bei mir auch 30,

Es ist bloß so, dass dein Array nur 29 Werte fasst.

[edit]Diesmal zu spät [edit]

AnsiString Ergebnis = "";
   int zahl[3];
   zahl[0] = 4;
   zahl[1] = 2;
   zahl[2] = 5;
   zahl[3] = 9;
   for (int i = 0; i <= 3; i++) Ergebnis = Ergebnis + IntToStr(zahl[i]) + "\n";

   ShowMessage(Ergebnis);

zeigt mir in einem mit [3] angegebenen Array 4 richtige Werte (0 - 3)

erzeugt bei dir undefiniertes Verhalten. Das bedeutet nicht, dass dein Programm abstürzt oder irgendwelche Fehlermeldungen kommen. Du beschreibst da einen Speicherbereich, der dir nicht gehört. Wenn dieser Bereich nicht weiter verwendet wird, passiert auch nichts (undefiniertes Verhalten).

Undefiniertes Verhalten bedeutet, dass Alles passieren kann (wirklichs Alles!). Also auch, dass dein Programm funktioniert.

das ist richtig.