Pętla (ang. loop) jest instrukcją
złożoną, która pozwala cyklicznie wykonywać zadaną instrukcję języka C++.
Pętla warunkowa (ang. conditional loop) wykonuje
powtarzanie w zależności od określonego warunku (takiego
samego jak dla&nbps;instrukcji warunkowej if).
W języku C++ wyróżniamy dwie
instrukcje pętli warunkowych:
while(warunek) instrukcja;lub while(warunek) |
Instrukcja wewnątrz pętli jest wykonywana dopóki warunek kontynuacji w instrukcji while jest prawdziwy. Warunek ten jest sprawdzany na początku każdego obiegu. Jeśli będzie fałszywy, to obieg nie zostanie wykonany i program przejdzie do wykonywania dalszej części swojego kodu za instrukcją while. Wynika z tego wniosek, że jeżeli warunek jest fałszywy przy rozpoczęciu wykonywania pętli, to zawarta w niej instrukcja nie zostanie wykonana ani jeden raz. |
do
instrukcja; while(warunek);lub do |
Działanie tej pętli jest podobne
do powyższej pętli while. Różnica polega jedynie na tym, iż warunek
jest tutaj sprawdzany na końcu obiegu. Jeśli będzie prawdziwy, to pętla
wykona następny obieg - zostanie powtórzone wykonanie zawartej w niej
instrukcji. Jeśli warunek będzie fałszywy, to wykonanie pętli zostanie
przerwane i program przejdzie do instrukcji leżących pod pętlą |
// Kolejne liczby naturalne
// od 1 do granicy g
//------------------------
#include <iostream>
using namespace std;
int main()
{
unsigned int i,g;
cin >> g;
i = 1;
while(i <= g) cout << i++ << " ";
cout << endl;
return 0;
}
|
// Kolejne liczby naturalne
// od 1 do granicy g
//------------------------
#include <iostream>
using namespace std;
int main()
{
unsigned int i,g;
cin >> g;
i = 1;
do cout << i++ << " "; while(i <= g);
cout << endl;
return 0;
}
|
Instrukcja break natychmiast przerywa wykonywanie pętli.
Wykorzystuje się ją w sytuacji, gdy dalsze powtarzanie wykonywania instrukcji w
pętli jest z pewnych względów niepożądane.
Instrukcja continue przerywa bieżący obieg pętli i natychmiast rozpoczyna
następny obieg. Wykorzystuje się ją w przypadku, gdy wykonywanie instrukcji w
bieżącym obiegu jest niepożądane.
//------------------------
#include <iostream>
using namespace std;
const int kod = J23;
int main()
{
int i,c;
i = 1;
do
{
cout << "WPISZ KOD : ";
cin >> c;
if(c == kod) break;
i++;
} while(i <= 3);
if(c == kod)
{
cout << "KOD ZAAKCEPTOWANY.\n\n";
return 0;
}
else
{
cout << "BRAK AUTORYZACJI.\n\n";
return 1;
}
}
|
Obiegi wykonywane przez pętlę można numerować. Obieg numerowany nazywamy iteracją. Iteracja wymaga dodatkowej zmiennej, która przechowuje numer wykonywanego przez pętlę obiegu. Zmienna ta nosi nazwę licznika pętli (ang. loop counter). Pętlę iteracyjną możemy utworzyć przy pomocy poznanych dotychczas pętli warunkowych.
Przykład:
Poniższe pętle wykonują 10 obiegów. Obiegi zliczane są przez zmienną i, która pełni tutaj rolę licznika pętli.
... i |
... i |
Ponieważ pętle iteracyjne pojawiają się w programach bardzo często, w języku C++ istnieje specjalna instrukcja do ich łatwej realizacji. Składnia tej instrukcji jest następująca:
for(prolog; kontynuacja; epilog)
instrukcja;
lub z instrukcją złożoną:
for(prolog; kontynuacja; epilog)
{
Ciąg instrukcji;
}
| prolog | - | instrukcja wykonywana przed rozpoczęciem pierwszej
iteracji. Najczęściej służy do inicjalizacji licznika pętli. Przykład:
|
| kontynuacja | - | warunek kontynuacji pętli. Jeśli wyrażenie to ma wartość
różną od 0, to pętla wykona obieg. Warunek jest sprawdzany na początku
każdej iteracji. Przykład:
|
| epilog | - | instrukcja wykonywana po zakończeniu każdej iteracji.
Najczęściej wykorzystuje się ją do modyfikacji licznika pętli. Przykład:
|
| instrukcja | - | instrukcja powtarzana w każdej iteracji pętli. Przykład:
|
W poniższych przykładach zakładamy, iż wszystkie niezbędne zmienne zostały wcześniej odpowiednio zadeklarowane.
Pętla wypisuje kolejne liczby całkowite od 1 do 10:
for(i = 1; i <= 10; i++) cout << i << endl;
Pętla wypisuje liczby od 10 do 1 w kierunku odwrotnym:
for(i = 10; i >= 1; i--) cout << i << endl;
Pętla wypisuje kolejne liczby parzyste od 4 do 26:
for(i = 4; i <= 26; i += 2) cout << i << endl;
Poniższy fragment programu wypisuje wiersz zbudowany z 20 znaków X:
for(i = 0; i < 20; i++) cout << "X";
cout << endl;
Jeśli powtórzymy ten fragment programu 20 razy, to otrzymamy kwadrat z literek X. Instrukcją powtarzaną w pętli może być druga pętla - otrzymamy wtedy układ zagnieżdżony:
for(j = 0; j < 20; j++)
{
for(i = 0; i < 20; i++) cout << "X";
cout << endl;
}
Pętla wewnętrzna jest sterowana zmienną i. Jej zadaniem jest wyświetlenie jednego wiersza 20 znaków X. Pętla ta jest powtarzana 20 razy przez pętlę zewnętrzną sterowaną zmienną j. W efekcie w oknie konsoli pojawia się 20 wierszy, każdy zbudowany z 20 literek X:
|
XXXXXXXXXXXXXXXXXXXX |
W pętlach zagnieżdżonych muszą być stosowane różne zmienne liczników pętli.
Jeśli ilość wykonań pętli wewnętrznej uzależnimy od numeru obiegu pętli zewnętrznej, to otrzymamy trójkąt:
for(j = 0; j < 20; j++)
{
for(i = 0; i <= j; i++) cout << "X";
cout << endl;
}
|
X |
Zastanów się, jak zmienić podane pętle, aby uzyskać następujące wydruki w oknie konsoli:
|
XXXXXXXXXXXXXXXXXXXX |
X |
XXXXXXXXXXXXXXXXXXXX |
|
XX |
Utwórz pętle, które tworzą następujące wydruki:
|
XXXXXXXXXXXXXXXX |
XXXXXXXXXXXXXXXX |
XXXXXXXXXXXXXXXX |
XXXXXXXXXXXXXXXX |
|
XXXX XXXX XXXX |
Trójka pitagorejska, to trzy liczby naturalne a, b i c, takie że:
a < b < c i a2 + b2 = c2
Słynnymi liczbami pitagorejskimi są na przykład liczby 3, 4 i 5. Zadanie sprowadza się do wygenerowania wszystkich trójek liczb a, b i c z przedziału od 1 do n, spełniających warunek
a < b < c:
a - generujemy od 1 do n - 2
b - generujemy od a + 1 do n - 1
c - generujemy od b + 1 do n
Zadanie generacji takich liczb spełnią trzy zagnieżdżone pętle iteracyjne, Następnie sprawdzamy w najbardziej wewnętrznej pętli, czy liczby te spełniają warunek trójki pitagorejskiej:
a2 + b2 = c2
Jeśli tak, to znalezioną trójkę wypisujemy.
// Trójki pitagorejskie
#include <iostream>
using namespace std;
int main()
{
int a,b,c,n;
cin >> n; // odczytujemy zakres
for(a = 1; a <= n - 2; a++)
for(b = a + 1; b <= n - 1; b++)
for(c = b + 1; c <= n; c++)
if(a*a + b*b == c*c) cout << a << " " << b << " " << c << endl;
return 0;
}
|