Können Sie mehrere Variablen in einem für die Schleife in C deklarieren++?
int i = 0;
int j = 0;
int k = 0;
Dies sind drei Aussagen, die in einer Erklärung geschrieben werden können, wie:
int i = 0, j = 0, k = 0;
Es gibt einen Datentyp; Die Ausdrücke werden durch Kommas getrennt. Eine Aussage endet mit einem Semikolon. Hier in einer Erklärung wurden hier mehrere Variablen deklariert.
Betrachten Sie nun die folgenden inkrementellen Aussagen:
int i ++;
int j ++;
int k ++;
Diese drei Aussagen können wie folgt durch eine Anweisung ersetzt werden:
int i ++, j ++, k ++;
Hier gibt es drei Ausdrücke in einer Anweisung für einen Datentyp.
Betrachten Sie auch die folgenden drei bedingten Aussagen:
ich < 10;
J < 10;
k < 10;
Diese drei Aussagen können wie folgt durch eine Erklärung ersetzt werden:
ich < 10 && j < 10 && k < 10;
Hier wurden drei Aussagen zu einem Ausdruck einer besonderen Form kombiniert. Diese Ausdrücke werden nicht wie in den obigen Fällen durch Kommas getrennt, sondern mit dem logischen und kombiniert.
In diesem Artikel erklärt. Sehr einfache Beispiele werden für Illustrationen verwendet.
Artikelinhalt
- Eine dimensionale Fürsoverzeitung
- Zweidimensionaler für Schlaufe
- Dreidimensionaler für Schlaufe
- Möglicher Vorteil
- Abschluss
Eine dimensionale Fürsoverzeitung
while-Schleife
Eine Weile, um Zahlen von Null auf 9 anzuzeigen, ist wie im folgenden Programm:
#enthalten
Verwenden von Namespace STD;
int main ()
int i = 0;
während ich < 10)
Cout << i << endl;
i ++;
Rückkehr 0;
Die erste Zeile im Programm enthält die iStream -Bibliothek für das Cout -Objekt. Die nächste Zeile im Programm ist eine Aussage. Es stellt sicher, dass jeder verwendete Name in der C ++ - Standardbibliothek stammt, sofern nicht anders angegeben.
In der Funktion main () gibt es die Initialisierungsanweisung der Ganzzahl, i = 0. Dann gibt es die While-Loop, die die Initialisierungsanweisung berücksichtigt. Die Zeit ist (ich < 10), and as long as i is less than 10 (never equal to 10), the cout iostream object in the body of the while-loop displays the value of i. The next statement in the while-loop increments i (adds 1 to the value of i).
Die Ausgabe ist wie folgt, wird jedoch vertikal angezeigt:
0 1 2 3 4 5 6 7 8 9
Eine dimensionale Fürsoverzeitung
Der Code in der oberen Main () -Funktion wird im folgenden Programm als For-Schleife reproduziert:
#enthalten
Verwenden von Namespace STD;
int main ()
für (int i = 0; i < 10; i++)
Cout << i << endl;
Rückkehr 0;
Der Ausgang ist der gleiche wie im obigen Fall. Die Initialisierungsanweisung für den oben genannten Code ist nun die erste Anweisung in den Klammern der For-Schleife, gefolgt von einem Semikolon. Die Bedingung für den obigen Code ist nun die zweite Aussage in den Klammern der For-Schleife, gefolgt von einem Semikolon. Die Increment-Anweisung im Körper der While-Loop für den vorherigen Code ist nun die dritte Anweisung in den Klammern der For-Loop. Es folgt kein Semikolon, weil es die letzte Aussage in den Klammern ist. Die einzige Aussage in der For-Loop zeigt den Wert von i an.
Zweidimensionaler für Schlaufe
Verschachtelt während des Schlusss
Die obige eindimensionale For-Loop zeigt eine Spalte an, wobei jede Zelle eine Zahl hat, den Wert von i. Eine Weile, die in einer anderen Weile verschachtelt war, würde eine Tabelle anzeigen, in der jede Zelle eine Zahl (den Wert von J an dieser Position) hat. Das folgende Programm zeigt dies:
#enthalten
Verwenden von Namespace STD;
int main ()
int i = 0;
während ich < 5)
int j = 0;
während (j < 5)
Cout << j << ";
J ++;
Cout << endl;
i ++;
Rückkehr 0;
Die Ausgabe ist:
0 1 2 3 4
0 1 2 3 4
0 1 2 3 4
0 1 2 3 4
0 1 2 3 4
Die I -Variable bestimmt die Zeilen. Die J -Variable bestimmt die Spalten. Die maximalen Werte für i und j sind in diesem Code jeweils 4. Kein Wert von I wird gedruckt. Für jeden Wert von j wird der Wert von j horizontal gedruckt. J wird inkrementiert, um den nächsten Wert horizontal für jede Zeile zu drucken.
Es gibt zwei Initialisierungsanweisungen: eine für i und eine für j, beide auf Null initialisiert. Die Initialisierungsanweisung für J befindet sich innerhalb der äußeren Schleife. Auf diese Weise wird J für jede Zeile wieder initialisiert (jede horizontale Linie). Auf diese Weise kann J für jede Zeile Zahlen von 0 bis 4 produzieren. Der Wert von Ich wird nie gedruckt; Es zeigt nur die Zeilennummer an. Ich bin außerhalb und unter der verschachtelten Schleife inkrementiert. Ich bin für den Zweck der nächsten Reihe inkrementiert.
Verschachtelte für die Schleife
Das folgende verschachtelte For-Schleife erzeugt das gleiche Ergebnis (Tabelle) wie die oben genannten während der Schleife:
#enthalten
Verwenden von Namespace STD;
int main ()
für (int i = 0; i < 5; i++)
für (int j = 0; j < 5; j++)
Cout << j << ";
Cout << endl;
Rückkehr 0;
Die Klammern jeder für die Schleife verfügen über eine eigene Initialisierungsaussage, eine eigene Bedingungsaussage und eine eigene Inkrementanweisung.
Eine während des Schleife
Die obige Tabellenausgabe kann mit einer Initialisierungsanweisung und einer Bedingungsaussage durch eine während der Schleife erzeugt werden. Die Neuzuordnung von Null zu J und das Inkrement von Ich muss jedoch in einem If-Construct auftreten. Der folgende Code zeigt dies:
#enthalten
Verwenden von Namespace STD;
int main ()
int i = 0, j = 0;
während ich < 5 && j <5)
Cout << j << ";
J ++;
if (j == 5)
Cout << endl;
J = 0;
i ++;
Rückkehr 0;
Die Ausgabe ist die gleiche Tabelle wie die oben genannte.
Eine For-Loop
Die obige Tabellenausgabe kann durch eine For-Schleife mit einer Initialisierungsanweisung und einer Bedingungsanweisung erzeugt werden. Die Neuzuordnung von Null zu J und das Inkrement von Ich muss jedoch in einem If-Construct auftreten. Das folgende Programm zeigt dies:
#enthalten
Verwenden von Namespace STD;
int main ()
für (int i = 0, j = 0; i < 5 && j <5; j++)
Cout << j << ";
if (j == 4)
Cout << endl;
J = -1;
i ++;
Rückkehr 0;
Die Ausgabe ist die gleiche Tabelle wie die oben genannte. Da J jedoch am Ende der Schleife in den Klammern inkrementiert ist, ist die If-Kondition (j == 4) und J wird für jede Zeile wieder zugewiesen, 1 -1.
Was hier räumlich ist, ist, dass zwei Variablen in einem Fürschleifen deklariert wurden. Und so können mehrere Variablen in einem Fürschleifen deklariert werden.
Führende diagonale Adressierung
In einem quadratischen Tisch ist die führende Diagonale die Diagonale vom oberen linken Ende bis zum unteren rechten Ende. Das folgende Programm zeigt die Koordinaten der führenden Diagonale der obigen Tabelle an:
#enthalten
Verwenden von Namespace STD;
int main ()
für (int i = 0, j = 0; i < 5 && j <5; i++,j++)
Cout << i << ',' << j << ";
Cout << endl;
Rückkehr 0;
Die Ausgabe ist:
0,0 1,1 2,2 3,3 4,4
Beachten Sie, dass im Programm zwei Variablen in den Klammern der For-Schleife deklariert wurden; Die Bedingung hat die beiden Variablen, die von der logischen und; und die Increment -Anweisung hat die beiden Variablen, die jeweils durch Hinzufügen eines erhöht werden. Unter diesem Zustand druckt die einzige Aussage im Körper des For-Loop die Koordinaten der führenden Diagonale.
Dreidimensionaler für Schlaufe
Es kann umständlich sein, alle Werte der Zellen eines Würfels zu drucken. Das folgende Programm druckt nur die Koordinaten der führenden Diagonale eines Würfels:
#enthalten
Verwenden von Namespace STD;
int main ()
für (int i = 0, j = 0, k = 0; i<5&&j<5&&k<5; i++,j++,k++)
Cout << i << ',' << j << ',' << k << ";
Cout << endl;
Rückkehr 0;
Die Ausgabe ist:
0,0,0 1,1,1 2,2,2 3,3,3 4,4,4
Beachten Sie, dass die Initialisierungsanweisung drei Variablen hat; Die Bedingungsanweisung hat die drei Variablen und die Increment -Anweisung die drei Variablen. Es gibt nur eine Aussage im Körper des For-Schleife.
Möglicher Vorteil
Betrachten Sie eine einzelne For-Schleife, um alle Werte der Zellen einer quadratischen Tabelle anzuzeigen:
Die beiden Variablen in der Initialisierungsanweisung und in der Bedingung bringt keinen Vorteil in der Geschwindigkeit, im Vergleich zu der Situation, in der eine Schleife verschachtelt ist.
Wenn jedoch nur ausgewählte Werte in der Tabelle zugegriffen werden sollen, würde die beiden Variablen in der Initialisierungsanweisung, in der Zustandsanweisung und in der Increment -Anweisung einen Vorteil in der Geschwindigkeit bringen; in dem Sinne, dass auf alle Werte nicht zugegriffen werden, bevor viele von ihnen beseitigt werden. Im folgenden Programm wird jedes andere Koordinatenpaar im führenden Diagonal gedruckt:
#enthalten
Verwenden von Namespace STD;
int main ()
für (int i = 0, j = 0; i < 10 && j <10; i+=2,j+=2)
Cout << i << ',' << j << ";
Cout << endl;
Rückkehr 0;
Die Ausgabe ist:
0,0 2,2 4,4 6,6 8,8
Es gibt immer noch nur eine Aussage in der Fürschleife. Auf diese Weise beinhaltet der Vorteil bei der Geschwindigkeitsvorteil. Die Initialisierungsausdrücke in der Initialisierungsanweisung müssen möglicherweise nicht auf Null initialisiert werden.
Im obigen Code lautet die Increment -Anweisung:
i+= 2, j+= 2
was bedeutet,
i = i+2, j = j+2;
Abschluss
Ja, ich kann mehrere Variablen in einer Fürschließung deklarieren. Auch Sie können jetzt mehrere Variablen in einer For-Schleife wie folgt deklarieren: Trennen Sie einfach die mehreren Variablen in der Initialisierungsanweisung mit Commas. Vergessen Sie nicht, die vollständige Initialisierungsanweisung mit einem Semikolon zu beenden. Wenn der Zugriff der Elemente der Struktur selektiv sein muss, müssen diese Variablen möglicherweise ebenfalls in der Bedingung und/oder in den Inkrementanweisungen in den Klammern der For-Schleife, möglicherweise mit einer zusätzlichen Logik, verwendet werden.