Anfänger für Schleifen Problem

Question

[EDIT] Whoops gab es einen Fehler im Code, und jetzt alle Antworten auf die Frage scheinen bizzare, aber im Grunde die for-Schleife verwendet werden, für (i = 0; i <15; i ++). Ich redigierte auch die Frage klarer zu machen. [/ EDIT]

Ich versuche eine for-Schleife zu bilden, das überprüft, eine 16-Element-Array, so dass es Schleifen von 0 bis 15 I i dann die Variable verwenden, später jedoch manchmal == i 16, die Probleme verursacht, von außerhalb der Grenzen sind, .

Ich habe eine Lösung, aber es funktioniert nicht elegant erscheinen, was mich denken lässt, ich bin etwas fehlt. Ich habe während Schlingen versucht, aber ich kann nie eine Schleife von 0 bis 15 holen, und nie mehr als 15 bei einem Wert zu beenden.

Gibt es eine Möglichkeit, eine Schleife gehen zu machen und alle 16 Elemente des Arrays zu überprüfen, während nie größer als 15 ist am Ende der Schleife?

int i;

for(i=0; i<16; i++)
{
    someClass.someMethod(i);

    if(someClass.Test())
    {
        break;
    }
}



if (i == 16)
{
    i = 15;
}

Answer 1

Ich schlage vor, eine andere Variable anders als i Verwendung nach Ihrer Schleife beendet ist. Die Kriterien einer for-Schleife statt einer while-Schleife ist, dass Sie vorher wissen genau, wie oft ein for-Schleife ausgeführt wird. Wenn Sie bereits wissen, dies nur eine andere Variable auf den Endwert der Schleife gesetzt und es verwenden, anstatt geben einen doppelten Zweck i.

int j = 15;

for(int i=0; i <= j; i++)
{
    someClass.array[i];
}

// continue on using j, which value hasn't changed

Answer 2

Gut für Starter, Ihr Beispielcode Schleifen von 0 bis 14. Aber wenn Sie Schleife von 0 bis 15, natürlich i sein muss 16 vor die Schleife enden kann. Was passiert, ist es 16 wird, dann Schleife merkt es außerhalb der Grenzen ist und ausbricht. Wenn Sie es bei 15 enden sollen, ehrlich die einfachste Sache zu tun, ist nur Dekrement kurz nach dem Loop-Ende.

Answer 3

i auf letzte Prüfung erhöht wird 16 zu sein, die als 15 nicht weniger ist, so Schleife beendet mit i 16 ist.

Answer 4

Vielleicht ist es nützlich zu wissen, dass:

for (before; check; after) { body } 

es ist das gleiche wie:

before 
while(check) { 
  body 
  after 
} 

Wenn Sie in diesem Begriff an Ihrem for-Schleife denken, vielleicht werden Sie herausfinden, leicht, warum ich am Ausgang ist 16

Answer 5

Es scheint einige grundlegende Mängel in Ihrem Ansatz zu sein.

1. Sie sollten nicht wirklich eine Indexvariable außerhalb des Bereichs der Schleife verwenden.
2. Sie sollten eine Variable oder Funktion verwenden, um die Grenze der Schleife zu bestimmen.
3. Es wäre besser, Iteratoren anstelle von numerischen Indizes verwendet werden.
4. Allg Algorithmen kann die Notwendigkeit Schleifen entfernen.

Just my $ 0,02.

Answer 6

Also - wenn Sie einen 16-Element-Array sind die Überprüfung, in der Regel würden Sie dies tun:

for(i=0; i<16; i++)

Wie für die Arbeiten ist es beginnt mit der ersten Aussage von drei:

i=0

Dann tut es Ihrem Scheck, in der zweiten Anweisung:

i < 16 // True here, since 0 < 16

Das geschieht vor Ihrer Schleife. Dann läuft er den Block Ihrer Schleife mit diesem Satz:

someClass.array[i]; //0

Schließlich tut es die Endabrechnung:

i++

Dann wiederholt sie die zweite und dritte Aussagen, in einer Folge.

Vor dem letzten Lauf, i == 14, dann tut es i ++, i bis 15 Einstellung und führt den Block. Schließlich ist es nicht i ++, Einstellung:

i==16

An diesem Punkt die Bedingung nicht mehr erfüllt ist:

i < 16 // False, since i==16

An diesem Punkt Ihr Block wird nicht ausgeführt, aber ich bin immer noch auf 16.

Answer 7

Sie müssen etwas verpasst haben.

In dieser Schleife würde es nicht einmal 15 treffen, würden Sie sagen müssen i = 15 <, sobald ich 14 = würde es laufen einmal und Kaution.

Answer 8

Die for Schleife entspricht den folgenden while loop:

i = 0;
while(i < 16) {
    someClass.array[i];

    i++;
} // while

i muss 16 erreichen richtig aus der Schleife zu erhalten.

Answer 9

Technisch gibt es Möglichkeiten des Schreibens die Schleife, so dass i 15 ist die Schleife beim Verlassen, aber man sollte sie nicht tun:

int i = 0;
while (1) {
    someclass.someMethod(i);
    if (i < 15) {
        i++;
    } else {
        break;
    }
}

Ja, es tut, was Sie fragen. Aber der Fluss ist schrecklich.

Answer 10

Sie können dies nicht erreichen mit den eingebauten Schleifenstrukturen und als Bill The Lizard sagte, wollen Sie wahrscheinlich nicht wirklich die for-Schleife Variable wieder zu verwenden.

Aber, wenn Sie wirklich wollen, hier eine Möglichkeit, es zu tun. Der Trick ist, die Schleifenbedingung in der Mitte der Schleife zu setzen:

int i = 0;
while (true)
{
    someclass.array[i];
    if (i == 15)
        break;
    ++i;
}

Answer 11

Die zentrale Frage hier zu verstehen ist, dass es 17 verschiedene Antworten auf die Frage sind „Welcher Wert von i den Test führt zum Erfolg?“. Entweder ich kann in {0, 1, ..., 15}, oder kein Wert von i bewirkt, dass der Test erfolgreich zu sein, die von i == 16 in diesem Fall bezeichnet. Also, wenn ich nur 16 Werte beschränkt ist, kann die Frage nicht beantwortet werden.

Es gibt legitime Fälle, in denen Sie nicht wollen, nach dem letzten gültigen Wert gehen. Zum Beispiel hatten, wenn Sie 256 Werte und aus irgendeinem Grund haben Sie nur ein Byte zu zählen mit. Oder, wie es vor kurzem mit mir passiert, dass Sie nur wollen jedes i-te Element eines Arrays untersuchen, und die letzte Ergänzung zu Ihrem Iterator bringen Sie weit über das Ende des Arrays. In diesen Fällen Schleifenentrollen ist erforderlich.

Doch für dieses Problem wäre es sauberer sein, eine Flagge zu verwenden:

bool flag = false;
for (int i = 0; i < 15; ++i) 
{
    someClass.someMethod(i);

    if (someClass.Test())
    {
        flag = true;
        break;
    }
}

Dann ist es klar, ob der Test überhaupt gelungen ist.

Answer 12

Wenn Sie Ihre Schleife natuarally endet, anstatt mit einer Pause, i wird sein 16. Es gibt keine Möglichkeit, dies zu vermeiden. Ihr Code ist durchaus akzeptabel, wenn, was Sie wollen, ist für i als 15, am Ende oder weniger:

int i;
for (i=0; i<16; i++) {
    someClass.someMethod(i);
    if (someClass.Test())
        break;
}
if (i == 16)
    i = 15;

Alles, was i 16-15 nach der Schleife ändert tun:

if (i == 16) i = 15;
i = (i == 16) ? 15 : i;
i = MAX (15,i); /* where MAX is defined :-) */

und so weiter.

Allerdings, die davon ausgeht, dass i verwendet für etwas werden wird sinnvoll als Post-Zustand in Bezug auf diese Schleife. Ich finde, das ist selten der Fall, die Menschen es erneut zu initialisieren neigen dazu, vor dem erneuten Gebrauch (wie ein andere für Schleife).

Darüber hinaus, was Sie tun macht es sehr schwierig (unmöglich, auch) als Post-Zustand, um herauszufinden, wheteher Ihre Schleife normal beendet oder ob sie vorzeitig beendet, weil someClass.Test() true zurückgegeben für i == 15. Das bedeutet, i mit weiterer Entscheidung zu treffen, ist mit Gefahren verbunden.

Meine Frage wäre: Warum glauben Sie i als 15 oder weniger

verlassen müssen

Answer 13

  

Ich versuche, ein for-Schleife zu machen, dass   16 überprüft eine Elementanordnung, so dass es Schleifen   von 0 bis 15 verwende ich dann die i   später variabel, aber manchmal i ==   16, die Probleme, indem sie bewirkt, dass aus   von Grenzen.

Sie müssen für den Fall überprüfen, wo Ihre for-Schleife nicht brechen, da diese Information bestimmt, ob oder nicht, was Sie tun wollten mit i gültig ist.

Es gibt ein paar Möglichkeiten, dies zu tun. Man ist in einem Bool Überblick zu behalten, wie „foundClass“ oder „testSucceeded“. Standard es falsch ist, dann setzen Sie ihn auf true auf Ihren Urlaub. Schließen Sie alle Anwendungen von i später in der Funktion in "if (foundClass) {}" Blöcke.

Ein weiterer Grund ist, um nur das zu tun, was Sie getan haben. Obwohl Ihr Rückfall sieht nicht die ganze Zeit Recht an. Wenn Sie i bis 15 sind einstellen, lügen Sie Ihren Code und sagen, dass someClass.Test () für i == 15 gelungen, was nicht wahr ist. Vermeiden Sie den Wert auf etwas einstellen, das falsch ist einfach so Ihr Code nicht später nicht Fehler. Es ist viel besser, Grenzen Kontrollen rund um die tatsächliche Nutzung von i später im Code zu setzen.

Answer 14

for(int i=0; i<17; i++)
{    
  if(i<16)
  {
     someClass.someMethod(i); 
     if(someClass.Test())   
     {        
       break;    
     }
  }
  else if(i==16)
  {
     i=15;
  }
}

Answer 15

Wenn Sie sagen, Sie haben ein Array mit 16 Elementen, die Sie nicht, dass definieren müssen, um das Array verwenden, um diese Informationen zu erhalten (DO INFORMATIONEN NICHT duplicate)

danach, wenn Sie der letzte Index wieder verwenden, um die Array erhalten möchten, dass Informationen zu erhalten.

for(int i = 0; i < myArray.length; ++i){
       myArray[i].somemethod();
}
// lastindex = myArray.length-1;