wake-up-neo.net

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

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

Zum Beispiel scheinen fast alle while-Anweisungen durch for-Anweisungen ersetzt zu werden, oder? Was ist dann der Vorteil von while?

70
user355546

Eine while-Schleife wertet die Bedingung immer zuerst aus.

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

Eine do/while-Schleife wird immer ausgeführt der Code im do{}-Block zuerst und bewerten Sie dann den Zustand.

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
}

Am Ende des Tages sind sie immer noch Schleifen, aber sie bieten ein wenig Flexibilität hinsichtlich ihrer Ausführung.

Hier ist eine großartige Erklärung für die Argumentation hinter der Verwendung der verschiedenen Arten von Schleifen, die zur Klärung beitragen können. Danke clyfe

Der Hauptunterschied zwischen den fors und die while's ist eine Sache von Pragmatiker: Normalerweise verwenden wir for, wenn Es gibt eine bekannte Anzahl von Iterationen, und verwende while-Konstrukte, wenn die Anzahl der Iterationen in .__ nicht bekannt. voraus. Der while vs do ... while Problem ist auch die Pragmatik, die Sekunde führt die Anweisungen einmal aus beim Start und danach verhält es sich genau wie die einfache Weile.


Denn Loops sind besonders schön, weil sie prägnant sind. Damit diese for-Schleife

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

um als while-Schleife geschrieben zu werden, müssen Sie Folgendes tun.

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

In diesem Fall gibt es einfach mehr Dinge, mit denen Sie Schritt halten können, und der count++; könnte in der Logik verloren gehen. Dies kann am Ende problematisch sein, abhängig davon, wo count inkrementiert wird und ob es vor oder nach der Logik der Schleife inkrementiert werden soll oder nicht. Bei einer for-Schleife wird Ihre Zählervariable vor der nächsten Iteration der Schleife immer inkrementiert, wodurch der Code etwas einheitlicher wird.


Der Vollständigkeit halber ist es wahrscheinlich sinnvoll, hier über break- und continue-Anweisungen zu sprechen, die sich für die Schleifenverarbeitung als nützlich erweisen.

break beendet die aktuelle Schleife sofort 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 'continue' den Ausdruck 'part3' von 'für (part1; part2; part3)' auswertet. Im Gegensatz dazu springt es in einer while-Schleife nur, um die Schleifenbedingung neu zu bewerten.

150
Robert Greiner

Wenn es große Bedenken hinsichtlich Geschwindigkeit und Leistung gibt, ist es am besten, den vom Compiler erzeugten Code auf Assembly-Ebene zu überprüfen.

Der folgende Code zeigt zum Beispiel, dass das "Do-while" etwas schneller ist. Dies liegt daran, dass die Anweisung "jmp" nicht von der "do-while" -Schleife verwendet wird.

BTW, in diesem speziellen Beispiel ist der schlechteste 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" -Schleife:

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);
15
psanzani

Der Lesbarkeit halber

10
hoang

Sie sind alle austauschbar. Sie können einen Typ auswählen und für immer nichts anderes als das verwenden, aber normalerweise ist einer für eine gegebene Aufgabe bequemer. Es ist so, als würde man sagen: "Warum haben Sie wechseln? Sie können nur eine Reihe von if-Anweisungen verwenden" - true, aber wenn ein übliches Muster zum Überprüfen einer Variablen auf einen Satz von Werten verwendet wird, ist es bequem und viel einfacher zu lesen, wenn es eine Sprachfunktion gibt das zu tun

10
Michael Mrozek

Wenn Sie möchten, dass eine Schleife ausgeführt wird, während eine Bedingung zutrifft, und nicht für eine bestimmte Anzahl von Iterationen, ist das für jemanden viel einfacher zu verstehen:

while (cond_true)

als so etwas:

for (; cond_true ; )
8
Justin Ethier

Denken Sie daran, dass eine for-Schleife im Wesentlichen eine ausgefallene while-Schleife ist. 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 besteht darin, dass es schwieriger ist, aus Versehen eine Endlosschleife auszuführen. Das heißt, es ist offensichtlicher, wenn Sie einen Befehl ausführen, da Sie im Allgemeinen die Schleifenvariable in die ursprüngliche Anweisung einfügen. 

Eine while-Schleife ist klarer, wenn Sie kein Standardinkrementierungsmuster ausführen. Zum Beispiel:

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

Ein häufiges Missverständnis mit whilefor-Schleifen, die ich je gesehen habe, ist, dass sich ihre Effizienz unterscheidet. While-Schleifen und for-Schleifen sind _/gleich effizient. Ich erinnere mich, dass mein Computerlehrer von der Highschool mir gesagt hat, dass Schleifen für Iterationen effizienter sind, wenn Sie eine Zahl erhöhen müssen. Das ist nicht der Fall.

For-Schleifen sind einfach syntaktisch hervorgehobenewhile-Schleifen und machen das Schreiben von Iterationscode schneller.

Wenn der Compiler Ihren Code übernimmt und ihn kompiliert, übersetzt er ihn in eine Form, die für den Computer leichter zu verstehen und auf einer niedrigeren Ebene auszuführen ist (Assembly). Während dieser Übersetzung gehen die subtilen Unterschiede zwischen den while- und for-Syntaxen verloren, und sie werden genau gleich.

4
Cam

Sie sollten eine solche Schleife verwenden, die den Anforderungen vollständig 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 "for" offensichtlich besser aus als "while" . Und "do while" sollte verwendet werden, wenn einige Operationen bereits ausgeführt werden müssen, bevor der Zustand der Schleife überprüft wird.

Entschuldigung für mein schlechtes Englisch).

4
abespalov

Eine for schlägt eine feste Iteration vor, die einen Index oder Varianten dieses Schemas verwendet.

Eine while und do... while sind Konstruktionen, die Sie verwenden, wenn eine Bedingung jedes Mal überprüft werden muss (abgesehen von einer indexähnlichen Konstruktion, siehe oben). Sie unterscheiden sich darin, wann die erste Prüfung der Bedingungsprüfung durchgeführt wird.

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

3
Pieter

Vor einiger Zeit ist mir aufgefallen, dass eine For-Schleife normalerweise mehr Maschinenbefehle als eine While-Schleife generiert. Wenn Sie sich jedoch die Beispiele genau ansehen, die meine Beobachtungen widerspiegeln, besteht der Unterschied aus 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. G.:

static int intStartWith = 100;

Der statische Modifikator bindet den Anfangswert in den Code und speichert (Trommelwirbel) one MOV-Anweisung. Wenn Sie eine Variable als statisch markieren, wird sie außerhalb des Stapelrahmens verschoben. Je nach variabler Ausrichtung kann auch etwas kleinerer Code erzeugt werden, da der MOV-Befehl und seine Operanden mehr Platz beanspruchen als beispielsweise eine Ganzzahl, ein Boolean-Wert oder ein Zeichenwert (entweder ANSI oder Unicode).

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

3
David A. Gray

Sie sind in ihrer Arbeit alle gleich. Sie können die gleichen Dinge mit jedem von ihnen machen. Sie unterscheiden sich jedoch in Bezug auf Lesbarkeit, Benutzerfreundlichkeit, Bequemlichkeit usw.

2
rahmivolkan

Ein Unterschied zwischen while und do-while besteht darin, dass zwar die Schleifenbedingung überprüft wird. Ist dies der Fall, wird der Body ausgeführt und die Bedingung erneut geprüft. Das do-while prüft den Zustand nach der Ausführung des Rumpfes, also wird der Rumpf mindestens einmal ausgeführt.

Natürlich können Sie eine while-Schleife als do-while und vv schreiben, aber dies erfordert normalerweise etwas Duplizierung von Code.

2
muksie

Für Schleifen (zumindest unter Berücksichtigung von C99) sind While-Schleifen überlegen, da sie den Umfang der inkrementierten Variablen begrenzen.

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

2
helpermethod

Zwischen für und während: while braucht weder eine Initialisierungs- noch eine Aktualisierungsanweisung, sodass sie besser und eleganter aussehen kann; Bei for können Anweisungen fehlen, eine oder alle zwei. Daher ist es am flexibelsten und am offensichtlichsten, wenn Sie vor der Schleife eine Initialisierung, eine Schleifenbedingung und ein "Update" benötigen. Wenn Sie nur eine Schleifenbedingung benötigen (am Anfang der Schleife getestet), ist while eleganter.

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

2
ShinTakezou

Während ist flexibler. FOR ist in den Fällen, in denen es gilt, knapper.

FOR ist ideal für Loops, die eine Art Zähler haben, wie

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

Sie können dasselbe mit einem WHILE erreichen, wie von anderen bereits bemerkt wurde, aber jetzt werden Initialisierung, Test und Inkrement in drei Zeilen aufgeteilt. Möglicherweise drei weit voneinander getrennte Zeilen, wenn der Körper der Schleife groß ist. Dies macht es für den Leser schwieriger zu sehen, was Sie tun. Immerhin ist "++ n" zwar ein sehr verbreitetes drittes Stück der FOR, aber 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 arbeiten. Mögen

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

Usw.

FOR bricht jedoch zusammen, wenn die Logik "Nächstes 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 Vorgang des Vorrückens abhängig von den während der Verarbeitung angetroffenen Bedingungen unterschiedlich sein kann, ist eine FOR-Anweisung nicht praktikabel. Ja, manchmal könnte man es mit kompliziert genug Ausdrücken machen, mit dem ternären Operator: usw., aber das macht den Code normalerweise weniger lesbar als lesbarer.

In der Praxis laufen die meisten meiner Schleifen entweder durch ein Array oder eine Struktur einer Art. 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).

2
Jay

Eine Besonderheit von do while ist, dass Sie nach der Weile ein Semikolon benötigen, um den Vorgang abzuschließen. Es wird häufig in Makrodefinitionen 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 Fehler beim Analysieren auftreten.

Eine Erklärung unter anderen

2
LB40

Sie sind mit Ausnahme der do-while-Schleife ziemlich gleich. Die for-Schleife ist gut, wenn Sie eine counter-Art von Variable haben. Das macht es offensichtlich. Die while-Schleife ist in den Fällen sinnvoll, in denen ein Flag wie unten gezeigt geprüft wird:

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

Die Anweisungen while und for können beide zum Durchlaufen der Programmierung verwendet werden. Es hängt vom Programmierer ab, ob die Schleife while oder for verwendet wird. Einige verwenden die while -Schleife, andere die for -Schleife.

Verwenden Sie eine beliebige Schleife. Die do...while -Schleife kann jedoch in der C-Programmierung etwas knifflig sein .

0
Ranjit Bhatta

/*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

kommen Sie nach Hause und gehen Sie nicht in den Laden, weil mein Geld = 0 Dollar ist * /

#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 die 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 https://www.youtube.com/watch?v=_vdvyzzp-R4&t=25s

0
sandeep bairwa