Für vs. während in der C-Programmierung?

Es gibt drei Schleifen in C: for, whileund do-while. Was ist der Unterschied zwischen ihnen?

Zum Beispiel scheinen fast alle whileAnweisungen durch forAnweisungen ersetzt zu werden , oder? Was ist dann der Vorteil while?

Eine while-Schleife wertet die Bedingung immer zuerst aus.

while (condition) {
  //gets executed after condition is checked
}

Eine do / while-Schleife führt immer zuerst den Code im do{}Block aus und wertet dann die Bedingung aus.

do {
  //gets executed at least once
} while (condition); 

Mit einer for-Schleife können Sie eine Zählervariable, eine Prüfbedingung und eine Möglichkeit zum Inkrementieren Ihres Zählers in einer Zeile initiieren.

for (int x = 0; x < 100; x++) {
   //executed until x >= 100
}

Letztendlich sind sie alle noch Schleifen, aber sie bieten eine gewisse Flexibilität hinsichtlich der Ausführung.

Hier finden Sie eine gute Erklärung der Gründe für die Verwendung der einzelnen Schleifentypen, die zur Klärung beitragen können. Danke Clyfe

Der Hauptunterschied zwischen dem forund dem whileist eine Frage der Pragmatik: Wir verwenden normalerweise, forwenn eine bekannte Anzahl von Iterationen bekannt ist, und verwenden whileKonstrukte, wenn die Anzahl der Iterationen nicht im Voraus bekannt ist. Das whilevs- do ... while Problem ist auch pragmatisch, das zweite führt die Anweisungen einmal beim Start aus und verhält sich danach genauso wie die einfache Weile.

For-Loops sind besonders schön, weil sie prägnant sind. Damit dies für die Schleife:

for (int x = 0; x < 100; x++) {
   //executed until x >= 100
}

Um als while-Schleife geschrieben zu werden, müssten Sie Folgendes tun:

int count = 0;
while (count < 100) {
  //do stuff
  count++;
}

In diesem Fall gibt es einfach mehr Dinge, mit denen man Schritt halten kann, und die count++;könnten in der Logik verloren gehen. Dies kann problematisch sein, je nachdem, wo es countinkrementiert wird und ob es vor oder nach der Logik der Schleife inkrementiert werden soll oder nicht. Bei einer forSchleife wird Ihre Zählervariable immer vor der nächsten Iteration der Schleife erhöht, wodurch Ihr Code einheitlicher wird.

Aus Gründen der Vollständigkeit, ist es wahrscheinlich sinnvoll , darüber zu sprechen breakund continueAussagen hier , die sich als nützlich erweisen , wenn die Schleifenverarbeitung zu tun.

break beendet sofort die aktuelle Schleife und es werden keine weiteren Iterationen ausgeführt.

//will only run "do stuff" twice
for (int x = 0; x < 100; x++) {
  if (x == 2) {
    break;
  }
  //do stuff
}

continue beendet die aktuelle Iteration und fährt mit der nächsten fort.

//will run "do stuff" until x >= 100 except for when x = 2
for (int x = 0; x < 100; x++) {
  if (x == 2) {
    continue;
  }
  //do stuff
}

Beachten Sie, dass in einer for-Schleife continueder part3Ausdruck von ausgewertet wird for (part1; part2; part3). Im Gegensatz dazu springt es in einer while-Schleife nur, um den Schleifenzustand neu zu bewerten.

Wenn große Bedenken hinsichtlich Geschwindigkeit und Leistung bestehen, besteht der beste Ansatz darin, den vom Compiler auf Assembly-Ebene erzeugten Code zu überprüfen.

Der folgende Code zeigt beispielsweise, dass das "do-while" etwas schneller ist. Dies liegt daran, dass der Befehl "jmp" nicht von der "do-while" -Schleife verwendet wird.

Übrigens ist in diesem speziellen Beispiel der schlimmste Fall durch die "for" -Schleife gegeben. :))

int main(int argc, char* argv[])
{
    int i;
    char x[100];

    // "FOR" LOOP:
    for (i=0; i<100; i++ )
    {
        x[i] = 0;
    }

    // "WHILE" LOOP:
    i = 0;
    while (i<100 )
    {
        x[i++] = 0;
    }

    // "DO-WHILE" LOOP:
    i = 0;
    do
    {
        x[i++] = 0;
    }
    while (i<100);

    return 0;
}

// "FOR" LOOP:

    010013C8  mov         dword ptr [ebp-0Ch],0
    010013CF  jmp         wmain+3Ah (10013DAh)

  for (i=0; i<100; i++ )
  {
      x[i] = 0;
    010013D1  mov         eax,dword ptr [ebp-0Ch]  <<< UPDATE i
    010013D4  add         eax,1
    010013D7  mov         dword ptr [ebp-0Ch],eax
    010013DA  cmp         dword ptr [ebp-0Ch],64h  <<< TEST
    010013DE  jge         wmain+4Ah (10013EAh)     <<< COND JUMP
    010013E0  mov         eax,dword ptr [ebp-0Ch]  <<< DO THE JOB..
    010013E3  mov         byte ptr [ebp+eax-78h],0
    010013E8  jmp         wmain+31h (10013D1h)     <<< UNCOND JUMP
  }

// "WHILE-SCHLEIFE:

  i = 0;
  010013EA  mov         dword ptr [ebp-0Ch],0
  while (i<100 )
  {
      x[i++] = 0;
    010013F1  cmp         dword ptr [ebp-0Ch],64h   <<< TEST
    010013F5  jge         wmain+6Ah (100140Ah)      <<< COND JUMP
    010013F7  mov         eax,dword ptr [ebp-0Ch]   <<< DO THE JOB..
    010013FA  mov         byte ptr [ebp+eax-78h],0
    010013FF  mov         ecx,dword ptr [ebp-0Ch]   <<< UPDATE i
    01001402  add         ecx,1
    01001405  mov         dword ptr [ebp-0Ch],ecx
    01001408  jmp         wmain+51h (10013F1h)      <<< UNCOND JUMP
  }

// "DO-WHILE" LOOP:

i = 0;
.  0100140A  mov         dword ptr [ebp-0Ch],0
  do
  {
      x[i++] = 0;
    01001411  mov         eax,dword ptr [ebp-0Ch]   <<< DO THE JOB..
    01001414  mov         byte ptr [ebp+eax-78h],0
    01001419  mov         ecx,dword ptr [ebp-0Ch]   <<< UPDATE i
    0100141C  add         ecx,1
    0100141F  mov         dword ptr [ebp-0Ch],ecx
    01001422  cmp         dword ptr [ebp-0Ch],64h   <<< TEST
    01001426  jl          wmain+71h (1001411h)      <<< COND JUMP
  }
  while (i<100);

Aus Gründen der Lesbarkeit

Sie sind alle austauschbar; Sie könnten einen Typ auswählen und nichts anderes als diesen für immer verwenden, aber normalerweise ist einer für eine bestimmte Aufgabe bequemer. Es ist so, als würde man sagen "Warum sollte man wechseln, man kann nur eine Reihe von if-Anweisungen verwenden" - wahr, aber wenn es ein allgemeines Muster ist, eine Variable auf eine Reihe von Werten zu überprüfen, ist es bequem und viel einfacher zu lesen, wenn es eine Sprachfunktion gibt das zu tun

Wenn Sie möchten, dass eine Schleife ausgeführt wird, während eine Bedingung erfüllt ist, und nicht für eine bestimmte Anzahl von Iterationen, ist es für andere Personen viel einfacher zu verstehen:

while (cond_true)

als so etwas:

for (; cond_true ; )

Denken Sie daran, eine forSchleife ist im Wesentlichen eine ausgefallene whileSchleife. Sie sind das gleiche.

while <some condition is true> {
   // do some stuff
   // possibly do something to change the condition
}


for ( some var, <some condition is true>; increment var ) {

}

Der Vorteil einer for-Schleife ist, dass es schwieriger ist, versehentlich eine Endlosschleife zu erstellen. Oder besser gesagt, es ist offensichtlicher, wenn Sie eine ausführen, da Sie im Allgemeinen die Schleifenvariable in die ursprüngliche Anweisung einfügen.

Eine whileSchleife ist klarer, wenn Sie kein Standard-Inkrementierungsmuster ausführen. Zum Beispiel:

int x = 1;
while( x != 10 ) {
  if ( some condition )
     x = 10;
  else 
     x += 5;
}

Sie sollten eine solche Schleife verwenden, die Ihren Anforderungen am besten entspricht. Zum Beispiel:

for(int i = 0; i < 10; i++)
{
    print(i);
}

//or

int i = 0;
while(i < 10)
{
    print(i);
    i++;
}

In einer solchen Situation sieht "für" offensichtlich besser aus als "während". Und "do while" sollte verwendet werden, wenn einige Operationen bereits vor dem Moment ausgeführt werden müssen, in dem der Zustand Ihrer Schleife überprüft wird.

Entschuldigung für mein schlechtes Englisch).

Ein häufiges Missverständnis mit while/ forloop, das ich gesehen habe, ist, dass ihre Effizienz unterschiedlich ist. WhileSchleifen und forSchleifen sind gleichermaßen effizient . Ich erinnere mich, dass mein Computerlehrer von der Highschool mir sagte, dass for-Schleifen für die Iteration effizienter sind, wenn Sie eine Zahl erhöhen müssen. Das ist nicht der Fall.

ForSchleifen sind einfach syntaktisch gezuckerte while Schleifen und beschleunigen das Schreiben von Iterationscode.

Wenn der Compiler Ihren Code nimmt und kompiliert, übersetzt er ihn in ein Formular, das für den Computer auf einer niedrigeren Ebene (Assembly) leichter zu verstehen und auszuführen ist. Während dieser Übersetzung gehen die subtilen Unterschiede zwischen der whileund der forSyntax verloren und werden genau gleich.

A forschlagen eine feste Iteration unter Verwendung eines Index oder von Varianten dieses Schemas vor.

A whileund do... whilesind Konstruktionen, die Sie verwenden, wenn eine Bedingung vorliegt, die jedes Mal überprüft werden muss (abgesehen von einer indexähnlichen Konstruktion, siehe oben). Sie unterscheiden sich darin, wann die erste Ausführung der Bedingungsprüfung durchgeführt wird.

Sie können beide Konstrukte verwenden, sie haben jedoch je nach Anwendungsfall ihre Vor- und Nachteile.

Ich habe vor einiger Zeit bemerkt, dass eine For-Schleife normalerweise mehr Maschinenanweisungen generiert als eine while-Schleife. Wenn Sie sich jedoch die Beispiele genau ansehen, die meine Beobachtungen widerspiegeln, beträgt der Unterschied zwei oder drei Maschinenanweisungen, die kaum eine Überlegung wert sind.

Beachten Sie auch, dass der Initialisierer für eine WHILE-Schleife durch Einbrennen in den Code entfernt werden kann, z.

static int intStartWith = 100;

Der statische Modifikator backt den Anfangswert in den Code und speichert (Trommelwirbel) einen MOV-Befehl. Wenn Sie eine Variable als statisch markieren, wird sie außerhalb des Stapelrahmens verschoben. Wenn die variable Ausrichtung dies zulässt, kann auch ein geringfügig kleinerer Code erzeugt werden, da der MOV-Befehl und seine Operanden mehr Platz beanspruchen als beispielsweise eine Ganzzahl, ein Boolescher Wert oder ein Zeichenwert (entweder ANSI oder Unicode).

Wenn Variablen jedoch an 8-Byte-Grenzen ausgerichtet sind, kostet eine allgemeine Standardeinstellung, ein in Code eingebranntes int, bool oder TCHAR die gleiche Anzahl von Bytes wie ein MOV-Befehl.

Sie sind alle gleich in ihrer Arbeit. Sie können die gleichen Dinge mit jedem von ihnen tun. Aus Gründen der Lesbarkeit, Benutzerfreundlichkeit, Benutzerfreundlichkeit usw. unterscheiden sie sich jedoch.

Ein Unterschied zwischen while und do-while besteht darin, dass während der Überprüfung der Schleifenbedingung und wenn dies zutrifft, der Body ausgeführt und die Bedingung erneut überprüft wird. Das do-while überprüft die Bedingung nach der Ausführung des Körpers, also wird mit do-while der Körper mindestens einmal ausgeführt.

Natürlich können Sie eine while-Schleife als do-while und vv schreiben, dies erfordert jedoch normalerweise eine gewisse Codeduplizierung.

Eine Besonderheit von do whileist, dass Sie nach einiger Zeit ein Semikolon benötigen, um fertig zu werden. In Makrodefinitionen wird es häufig verwendet, um mehrere Anweisungen nur einmal auszuführen, während die Auswirkungen des Makros eingeschränkt werden. Wenn Makros als Blöcke definiert wurden, können einige Analysefehler auftreten.

Eine Erklärung unter anderem

For-Schleifen (zumindest unter Berücksichtigung von C99) sind while-Schleifen überlegen, da sie den Umfang der inkrementierten Variablen einschränken.

Do while-Schleifen sind nützlich, wenn die Bedingung von einigen Eingaben abhängt. Sie werden von den drei Schleifentypen am seltensten verwendet.

Zwischen für und während: while Benötigt weder eine Initialisierung noch eine Aktualisierungsanweisung, sodass es möglicherweise besser und eleganter aussieht. forEs können Anweisungen fehlen, eine zwei oder alle. Daher ist es am flexibelsten und offensichtlichsten, wenn Sie vor dem Schleifen Initialisierung, Schleifenbedingung und "Aktualisierung" benötigen. Wenn Sie nur eine Schleifenbedingung benötigen (am Anfang der Schleife getestet), whileist dies eleganter.

Zwischen for / while und do-while : in do-whileder Bedingung wird am Ende der Schleife ausgewertet. Bequemer, wenn die Schleife mindestens einmal ausgeführt werden muss.

WÄHREND flexibler ist. FOR ist in den Fällen, in denen es gilt, prägnanter.

FOR eignet sich hervorragend für Loops, die einen Zähler haben, wie z

for (int n=0; n<max; ++n)

Sie können das Gleiche natürlich mit einem WHILE erreichen, wie andere bereits betont haben, aber jetzt sind Initialisierung, Test und Inkrement in drei Zeilen unterteilt. Möglicherweise drei weit voneinander entfernte Linien, wenn der Körper der Schleife groß ist. Dies macht es für den Leser schwieriger zu sehen, was Sie tun. Obwohl "++ n" ein sehr verbreitetes drittes Stück des FOR ist, ist es sicherlich nicht die einzige Möglichkeit. Ich habe viele Schleifen geschrieben, in denen ich "n + = Inkrement" oder einen komplexeren Ausdruck schreibe.

FOR kann natürlich auch gut mit anderen Dingen als einem Zähler zusammenarbeiten. Mögen

for (int n=getFirstElementFromList(); listHasMoreElements(); n=getNextElementFromList())

Etc.

FOR bricht jedoch zusammen, wenn die Logik "Das nächste Mal durch die Schleife" komplizierter wird. Erwägen:

initializeList();
while (listHasMoreElements())
{
  n=getCurrentElement();
  int status=processElement(n);
  if (status>0)
  {
    skipElements(status);
    advanceElementPointer();
  }
  else
  {
    n=-status;
    findElement(n);
  }
}

Das heißt, wenn der Fortschrittsprozess abhängig von den während der Verarbeitung auftretenden Bedingungen unterschiedlich sein kann, ist eine FOR-Anweisung unpraktisch. Ja, manchmal können Sie dafür sorgen, dass es mit ausreichend komplizierten Ausdrücken, der Verwendung des ternären ?: Operators usw. funktioniert, aber das macht den Code normalerweise weniger lesbar als besser lesbar.

In der Praxis durchlaufen die meisten meiner Schleifen entweder ein Array oder eine Struktur. In diesem Fall verwende ich eine FOR-Schleife. oder lesen eine Datei oder eine Ergebnismenge aus einer Datenbank. In diesem Fall verwende ich eine WHILE-Schleife ("while (! eof ())" oder etwas Ähnliches).

Sie sind bis auf die do-whileSchleife ziemlich gleich . Die forSchleife ist gut, wenn Sie eine counterArt Variable haben. Es macht es offensichtlich. whileSchleife ist in Fällen sinnvoll, in denen ein Flag wie unten gezeigt überprüft wird:

while (!done) {
   if (some condtion) 
      done = true;
}

whileund forAnweisungen können beide zum Schleifen in der Programmierung verwendet werden. Es hängt vom Programmierer ab, ob die whileSchleife oder die forSchleife verwendet wird. Einige sind mit whileSchleife vertraut, andere mit forSchleife.

Verwenden Sie eine beliebige Schleife. Die do...whileSchleife kann jedoch bei der C-Programmierung etwas schwierig sein .

/* while-Schleife

5 Dollar

1 Schokolade = 1 Dollar

while my money is greater than 1 bucks 
  select chocolate
  pay 1 bucks to the shopkeeper
  money = money - 1
end

Komm nach Hause und kann nicht einkaufen gehen, weil mein Geld = 0 Dollar * /

#include<stdio.h>
int main(){
  int money = 5;

  while( money >= 1){   
    printf("inside the shopk and selecting chocolate\n");
    printf("after selecting chocolate paying 1 bucks\n");
    money = money - 1 ;  
    printf("my remaining moeny = %d\n", money);
    printf("\n\n");
  }

  printf("dont have money cant go inside the shop, money = %d",  money);

  return 0;
} 

unendlich viel Geld

while( codition ){ // condition will always true ....infinite loop
  statement(s)
}

Bitte besuchen Sie dieses Video zum besseren Verständnis https://www.youtube.com/watch?v=eqDv2wxDMJ8&t=25s

/ * für Schleife

5 Dollar

for my money is greater than equal to 1 bucks   0      money >= 1
  select chocolate
  pay 1 bucks to the shopkeeper
  money = money - 1  1-1 => 0
end

* /

#include<stdio.h>
int main(){

  int money = 5;
  for( ; money >= 1; ){     0>=1  false 
    printf("select chocolate \n");
    printf("paying 1 bucks to the shopkeeper\n");
    money = money - 1;    1-1 = 0
    printf(" remaining money =%d\n", money);
    printf("\n\n");
  }

  return 0;
}

Zum besseren Verständnis besuchen Sie bitte https://www.youtube.com/watch?v=_vdvyzzp-R4&t=25s