Czy możesz zadeklarować wiele zmiennych w pętli w C++?
int i = 0;
int j = 0;
int k = 0;
Są to trzy stwierdzenia, które można zapisać w jednym stwierdzeniu, ponieważ:
int i = 0, j = 0, k = 0;
Istnieje jeden typ danych; Wyrażenia są oddzielone przez przecinki. Oświadczenie kończy się jednym półkolisem. W jednym stwierdzeniu zadeklarowano wiele zmiennych.
Teraz rozważ następujące instrukcje przyrostowe:
int i ++;
int J ++;
int k ++;
Te trzy stwierdzenia można zastąpić jednym stwierdzeniem, w następujący sposób:
int I ++, J ++, K ++;
Tutaj istnieją trzy wyrażenia w jednym instrukcji dla jednego typu danych.
Rozważ także następujące trzy warunkowe stwierdzenia:
I < 10;
J < 10;
k < 10;
Te trzy stwierdzenia można zastąpić jednym stwierdzeniem, jak następuje:
I < 10 && j < 10 && k < 10;
Tutaj trzy stwierdzenia zostały połączone w jedno wyrażenie specjalnej formy. Wyrażenia te nie są oddzielone przecinkami, jak w powyższych przypadkach, ale są one łączone z logicznymi i.
W tym artykule wyjaśniono, w jaki sposób można zadeklarować i użyć wielu zmiennych w pętli, z regularnymi korespondencjami. Do ilustracji używane są bardzo proste przykłady.
Treść artykułu
- Jeden wymiarowy dla pętli
- Dwuwymiarowy dla pętli
- Trójwymiarowy dla pętli
- Możliwa przewaga
- Wniosek
Jeden wymiarowy dla pętli
While pętli
Pętla w trakcie wyświetlania liczb od zera do 9, jest jak w następującym programie:
#włączać
za pomocą przestrzeni nazw Std;
int main ()
int i = 0;
podczas gdy ja < 10)
Cout << i << endl;
i ++;
powrót 0;
Pierwsza linia w programie zawiera bibliotekę iostream dla obiektu Cout. Następny wiersz w programie jest stwierdzenie. Zapewnia, że każda użyta nazwa pochodzi z standardowej biblioteki C ++, chyba że wskazano inaczej.
W funkcji main () istnieje instrukcja inicjalizacji całkowitej, i = 0. Następnie jest pętla pobytu, która uwzględnia oświadczenie inicjalizacyjne. Jest to kwalifikacja (ja < 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).
Wyjście jest następujące, ale wyświetlane pionowo:
0 1 2 3 4 5 6 7 8 9
Jeden wymiarowy dla pętli
Kod w powyższej funkcji main () jest odtwarzany w następującym programie, jako pętla:
#włączać
za pomocą przestrzeni nazw Std;
int main ()
dla (int i = 0; i < 10; i++)
Cout << i << endl;
powrót 0;
Wyjście jest takie same jak w powyższej sprawie. Instrukcja inicjalizacji dla powyższego kodu jest teraz pierwszym stwierdzeniem w nawiasach za pętla, a następnie półkolis. While kwalifikujący powyższy kod jest teraz drugim stwierdzeniem w nawiasach za pętla, a następnie półkolis. Oświadczenie przyrostowe w korpusie pętli pobytu, dla poprzedniego kodu, jest teraz trzecim stwierdzeniem w nawiasach na pętlę. Nie następuje półkolis, ponieważ jest to ostatnie stwierdzenie w nawiasach. Jedyne stwierdzenie w pętli wyświetla wartość i.
Dwuwymiarowy dla pętli
Zagnieżdżona pętla pobytu
Powyższe jednowymiarowe dla pętli wyświetla jedną kolumnę, w której każda komórka ma liczbę, wartość i. Pętla w pobycie, zagnieżdżona w innej pętli, wyświetlałaby tabelę, w której każda komórka miałaby liczbę (wartość J w tej pozycji). Poniższy program ilustruje to:
#włączać
za pomocą przestrzeni nazw Std;
int main ()
int i = 0;
podczas gdy ja < 5)
int j = 0;
While (j < 5)
Cout << j << ";
J ++;
Cout << endl;
i ++;
powrót 0;
Wyjście to:
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
Zmienna I określa wiersze. Zmienna J określa kolumny. Maksymalne wartości dla I i J to każde 4 w tym kodzie. Nie jest drukowana żadna wartość I. Dla każdej wartości j wartość j jest drukowana poziomo. J jest zwiększane do wydrukowania następnej wartości poziomo dla każdej linii.
Istnieją dwa instrukcje inicjalizacyjne: jedno dla ja i jeden dla J, oba zainicjowane do zera. Instrukcja inicjalizacji dla J znajduje się w pętli zewnętrznej. W ten sposób J jest ponowna dla każdego wiersza (każda linia pozioma). W ten sposób J może wytwarzać liczby od 0 do 4 dla każdego wiersza. Wartość I nigdy nie jest drukowana; Wskazuje tylko numer wiersza. Jestem zwiększony na zewnątrz i poniżej zagnieżdżonej pętli. Jestem zwiększony do celów następnego rzędu.
Zagnieżdżony za pętlę
Poniższe zagnieżdżone na pętli daje ten sam wynik (tabela), co powyższa zagnieżdżona pętla w pobycie:
#włączać
za pomocą przestrzeni nazw Std;
int main ()
dla (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
Cout << j << ";
Cout << endl;
powrót 0;
Każde nawiasy dla pętli mają własne oświadczenie inicjalizacyjne, własne stwierdzenie stanu i własne instrukcje przyrostowe.
Jedna pętla w pobycie
Powyższe wyjście tabeli można wytwarzać za pomocą jednej pętli, z jedną instrukcją inicjalizacyjną i jednym instrukcją warunku. Jednak ponowna przypisanie od zera do J i przyrost I musi wystąpić w konstruowaniu IF. Poniższy kod to ilustruje:
#włączać
za pomocą przestrzeni nazw Std;
int main ()
int i = 0, j = 0;
podczas gdy ja < 5 && j <5)
Cout << j << ";
J ++;
if (j == 5)
Cout << endl;
j = 0;
i ++;
powrót 0;
Wyjście to ta sama tabela co ta powyżej.
Jeden za pętlę
Powyższe wyjście tabeli można wytwarzać jedną za pętlę, z jedną instrukcją inicjalizacyjną i jednym instrukcją warunku. Jednak ponowna przypisanie od zera do J i przyrost I musi wystąpić w konstruowaniu IF. Poniższy program ilustruje to:
#włączać
za pomocą przestrzeni nazw Std;
int main ()
for (int i = 0, j = 0; i < 5 && j <5; j++)
Cout << j << ";
if (j == 4)
Cout << endl;
j = -1;
i ++;
powrót 0;
Wyjście to ta sama tabela co ta powyżej. Jednak tutaj, ponieważ J jest zwiększane na końcu pętli, w nawiasach, klimat IF wynosi (j == 4), a J jest ponownie przypisywany, -1 dla każdego wiersza.
To, co jest tutaj przestrzenne, to to, że dwie zmienne zostały zadeklarowane w pętli. I tak wiele zmiennych można zadeklarować w pętli.
Wiodące adresowanie po przekątnej
W kwadratowym stole wiodącym przekątnym jest przekątna od lewej końcówki do dolnego końca. Poniższy program wyświetla współrzędne wiodącej przekątnej powyższej tabeli:
#włączać
za pomocą przestrzeni nazw Std;
int main ()
for (int i = 0, j = 0; i < 5 && j <5; i++,j++)
Cout << i << ',' << j << ";
Cout << endl;
powrót 0;
Wyjście to:
0,0 1,1 2,2 3,3 4,4
Zauważ, że w programie dwie zmienne zostały zadeklarowane w nawiasach For Looop; Warunek ma dwie zmienne, powiązane przez logiczne i; a instrukcja przyrostowa ma dwie zmienne, każda z nich zwiększała, dodając jedną. W tym stanie jedno stwierdzenie w treści for-pętli drukuje współrzędne wiodącego przekątnego.
Trójwymiarowy dla pętli
Drukowanie wszystkich wartości komórek kostki może być uciążliwe. Poniższy program po prostu drukuje współrzędne wiodącego przekątnego kostki:
#włączać
za pomocą przestrzeni nazw Std;
int main ()
for (int i = 0, j = 0, k = 0; i<5&&j<5&&k<5; i++,j++,k++)
Cout << i << ',' << j << ',' << k << ";
Cout << endl;
powrót 0;
Wyjście to:
0,0,0 1,1,1 2,2,2 3,3,3 4,4,4
Zauważ, że instrukcja inicjalizacji ma trzy zmienne; Instrukcja warunku ma trzy zmienne, a instrukcja przyrostowa ma trzy zmienne. Jest tylko jedno stwierdzenie w ciele z powodu pętli.
Możliwa przewaga
Rozważ pojedynczą pętlę, aby wyświetlić wszystkie wartości komórek kwadratowej tabeli:
Posiadanie dwóch zmiennych w instrukcji inicjalizacji i w stanie nie przynosi żadnej przewagi w prędkości, w porównaniu z sytuacją, w której zagnieżdżona jest jedna pętla.
Jeśli jednak mają być dostępne tylko wybrane wartości w tabeli, posiadanie dwóch zmiennych, w instrukcji inicjalizacji, w instrukcji warunku, a w instrukcji przyrostowej przyniósłby przewagę prędkości; w tym sensie, że wszystkie wartości nie będą dostępne, zanim wyeliminują wiele z nich. W poniższym programie wydrukowana jest każda inna para współrzędnych, w wiodącym przekątnym:
#włączać
za pomocą przestrzeni nazw Std;
int main ()
for (int i = 0, j = 0; i < 10 && j <10; i+=2,j+=2)
Cout << i << ',' << j << ";
Cout << endl;
powrót 0;
Wyjście to:
0,0 2,2 4,4 6,6 8,8
W pętli jest jeszcze tylko jedno stwierdzenie. W ten sposób uzyskanie przewagi w prędkości obejmuje dodatkową logikę selektywną w instrukcji stanu i/lub w instrukcji przyrostowej. Wyrażenia inicjalizacji w instrukcji inicjalizacji mogą nie być inicjowane do zera.
W powyższym kodzie instrukcja przyrostu jest:
i+= 2, j+= 2
co znaczy,
i = i+2, j = j+2;
Wniosek
Tak, mogę zadeklarować wiele zmiennych w pętli. Ty również możesz teraz zadeklarować wiele zmiennych, w pętli, w następujący sposób: po prostu oddzień wiele zmiennych w instrukcji inicjalizacji za pomocą przecinków. Nie zapomnij zakończyć pełnego oświadczenia inicjalizacyjnego półkolisem. Jeśli dostęp do elementów struktury musi być selektywny, wówczas zmienne te mogą być również wymagane, w instrukcjach stanu i/lub przyrostu, w nawiasach za pętla, być może z dodatkową logiką.