Jak używać podczas pętli w C ++

Pętla While jest jednym z najczęściej używanych typów pętli w języku programowania C ++ ze względu na szeroki zakres aplikacji. While pętla może powtórzyć określony kod kilka razy, aż do spełnienia warunku przerwy. W tym artykule obejmuje składnię i przykłady używania pętli w czasie w C++.

Spis treści:

• Co jest podczas pętli w C++
• Składnia While Pętla
• Jak używać podczas pętli w C++
• C ++ zagnieżdżone podczas pętli
• C ++ nieskończone podczas pętli
• Drukowanie równych i nieparzystych z pętlami w C++
• Wniosek

Co jest podczas pętli w C++

Pętla, jest strukturą kontrolną, która będzie nadal działać tak długo, jak warunek oceni do true, i zatrzyma się, gdy warunek stanie się fałszywy. Jest to przydatne w przypadkach, w których chcesz powtórzyć określone zadanie, dopóki nie zostanie spełniony określony warunek.

Na przykład, Możesz użyć pętli while do drukowania liczb od 1 do 10 lub obliczenia czynnikowego danego numeru.

Składnia While Pętla

Podstawowa składnia pętli w While w C ++ jest następująca:

while (warunek)
// kod do wykonania

Kod w klamrach kręconych będzie wykonywany wielokrotnie, o ile warunek jest prawdziwy. Warunek będzie sprawdzany za każdym razem, gdy pętla będzie działać.

Jak używać podczas pętli w C++

Jeden z najczęstszych przykładów, w których pętle liczą od punktu początkowego do punktu końcowego. Na przykład, Poniższy kod będzie się liczył od 1 do 10:

#włączać
za pomocą przestrzeni nazw Std;
int main ()
int i = 1; // zainicjuj zmienną licznika do 1
// pętla, gdy zmienna licznika jest mniejsza lub równa 10
podczas gdy ja <= 10)
Cout << i << endl; // output the current value of the counter variable
i ++; // zwiększaj zmienną licznika

powrót 0;

Ten kod pokazuje, jak używać pętli w C w C++. Program inicjuje zmienną kontratakową I do 1, a następnie wykonać pętlę, która będzie trwać do czasu do I staje się większy niż 10.

Wewnątrz pętli While bieżąca wartość zmiennej licznika jest drukowana do konsoli za pomocą Cout stwierdzenie, a następnie przerwa w linii za pomocą Endl. Zmienna licznika jest następnie zwiększana o 1 za pomocą I++ oświadczenie.

Pętla nadal wykona się, aż do zmiennej kontratakowej I osiąga wartość 11, w którym to momencie pętla, a program kończy się z wartością zwrotną 0.

C ++ zagnieżdżone podczas pętli

While mogą być również pętle zagnieżdżony, co oznacza, że ​​możesz mieć trochę w czasie pętli w innej pętli. Jest to przydatne w przypadkach, w których trzeba wykonywać zadanie wielokrotnie, dopóki nie zostanie spełniony określony warunek, a w tym zadaniu trzeba wykonywać inne zadanie wielokrotnie, aż do spełnienia innego stanu.

W zagnieżdżonej pętli, pętla zewnętrzna jest wykonywana raz, a następnie wewnętrzna pętla będzie wykonywana za każdym razem, gdy pętla zewnętrzna będzie działać. Wewnętrzna pętla jest wykonywana w pełni raz na każdą iteracji zewnętrznej pętli.

Przykład

Poniżej znajduje się przykładowy kod używania zagnieżdżonych podczas pętli w C ++:

#włączać
za pomocą przestrzeni nazw Std;
int main ()
int i = 1; // zainicjuj zmienną licznika do 1
// pętla, podczas gdy zmienna licznika jest mniejsza lub równa 3
podczas gdy ja <= 3)
int j = 1; // zainicjuj wewnętrzną zmienną licznika do 1
// pętla, podczas gdy wewnętrzna zmienna licznika jest mniejsza lub równa 3
While (j <= 3)
Cout << i << " " << j << "\n"; // output the current values of the counter variables
J ++; // Zwiększenie wewnętrznej zmiennej licznika

i ++; // zmienna licznika zewnętrznej zwiększają

powrót 0;

W tym kodzie zewnętrzna pętla działa tak długo, jak I staje się równa 3, gdy wartość I staje się większa niż 3 pętla zatrzyma się. Z każdą iteracją pętli zewnętrznej wewnętrzna zmienna licznika J jest inicjowany do 1 i wykonuje wewnętrzne pętle. Ta wewnętrzna pętla będzie działać do wartości J staje się większy niż 3.

Wewnątrz wewnętrznej pętli wyprowadzamy wartości I I J. Następnie zwiększyliśmy J. Trwa to do momentu trzykrotnego wykonania wewnętrznej pętli. Za każdym razem, gdy pętla zewnętrzna jest zwiększana, pętla wewnętrzna również zostanie wykonana ponownie.

Proces ten powtarza się, aż zewnętrzna pętla zostanie wykonana trzykrotnie i obie pętle się skończyły. Wyjście tego kodu to tabela wartości od 1 1 do 3 3, jak pokazano na poniższym obrazku.

C ++ nieskończone podczas pętli

W C ++ nieskończone, gdy pętle są również możliwe. Nieskończony, podczas gdy pętla działa w sposób ciągły, ponieważ żaden warunek nie może być fałszywy. Jest tylko jeden prawdziwy warunek, To pozwala na ciągłe działanie pętli podczas nieskończonej liczby razy.

Na przykład, Poniższa pętla poniżej wykona się na zawsze i aby zatrzymać tę pętlę, musimy zdefiniować instrukcję przerwy na końcu tej pętli.

while (true)
// kod do wykonania

Nieskończona pętla może być przydatna w niektórych przypadkach, na przykład w systemach osadzonych lub podczas oczekiwania na wprowadzanie użytkownika.

Przykład

Poniżej znajduje się przykład programu C ++, który uruchamia nieskończoną pęt w kodzie C ++:

#włączać
za pomocą przestrzeni nazw Std;
int main ()
int count = 0;
while (true)
Cout<<"Infinitive While Loop\n";
count ++;
if (count> = 10)
przerwa;


powrót 0;

Dany kod tworzy nieskończoną pętlę, która stale wysyła ciąg „bezokolicznikowy” do konsoli. Wynika to z faktu, że warunek pętli jest ustawiony na true, co zawsze jest prawdziwą pętlą.

Aby zatrzymać nieskończoną pętlę, możemy użyć instrukcji Break, aby wyjść z pętli, gdy spełniony jest określony warunek. W powyższym programie ustawiliśmy maksymalną liczbę iteracji na 10, które są kontrolowane przez liczyć Zmienna i instrukcja przerwy.

Powyższy kod będzie działał na nieskończone czasy, ale użycie instrukcji przerwy zatrzyma go po 10 iteracjach.

Drukowanie równych i nieparzystych z pętlą

Kolejnym przykładem, w których pętle są drukowane nawet i nieparzyste liczby. Na przykład, Poniższy podany kod wykorzystuje pętlę w czasie w C ++, aby wyświetlić liczby parzyste od 2 do 10.

#włączać
za pomocą przestrzeni nazw Std;
int main ()
int i = 2; // zainicjuj zmienną licznika do 2
// pętla, podczas gdy zmienna licznika jest mniejsza lub równa 10
podczas gdy ja <= 10)
Cout << i << endl; // output the current value of the counter variable
i += 2; // zwiększaj zmienną licznika o 2

powrót 0;

Ten kod C ++ inicjuje zmienną kontratakową I do 2 i używa pętli podczas wielokrotnego wysyłania wartości I tak długo, jak jest mniejsze lub równe 10. Przy każdej iteracji pętli wzrasta I przez 2. Za każdym razem, gdy pętla uruchamia wyjście wyjściowe na terminalu. Po zakończeniu pętli program zwraca 0, aby wskazać pomyślne wykonanie.

Podobnie możemy również wydrukować dziwne Liczby od 1 do 9:

#włączać
za pomocą przestrzeni nazw Std;
int main ()
int i = 1; // zainicjuj zmienną licznika do 1
// pętla, podczas gdy zmienna licznika jest mniejsza lub równa 9
podczas gdy ja <= 9)
Cout << i << endl; // output the current value of the counter variable
i += 2; // zwiększaj zmienną licznika o 2

powrót 0;

W tym kodzie warunek pętli będzie działał aż do zmiennej licznika I jest mniejsze lub równe 9. Cout instrukcja wewnątrz pętli wyświetla bieżącą wartość I, A potem I zmienna jest zwiększana o 2 za pomocą I += 2 oświadczenie. Zapewnia to, że tylko liczby nieparzyste są wydrukowane przez pętlę.

Na końcu programu instrukcja powrotu służy do wskazania, że ​​funkcja main () jest zakończona.

Wniosek

Pętla z chwilami jest strukturą kontrolną, która uruchamia program tak długo, jak określony warunek jest prawdziwy. Tutaj omówiliśmy podstawową składnię i przykłady używania pobytu w C++. Opisujemy również, jak korzystać z pętli w formie zagnieżdżonej i jak można działać podczas pętli nieskończonej liczby razy. Aby uzyskać więcej informacji na temat C ++ podczas pętli, przeczytaj artykuł.