W języku C++ do wykonywania powtarzalnych operacji służą pętle. Pętle pozwalają na wielokrotne wykonanie fragmentu kodu w zależności od spełnienia określonego warunku lub warunków. C++ oferuje kilka rodzajów pętli:
Pętla for
Pętla
for jest używana, gdy liczba iteracji jest znana przed rozpoczęciem pętli. Składa się z trzech opcjonalnych części: inicjalizacji, warunku kontynuacji i aktualizacji, oddzielonych średnikami.
for (inicjalizacja; warunek; inkrementacja) {
// Kod do wykonania
}
Przykłady:
for(int i = 0; i < 5; i++) {
cout << i << " ";
}
Wypisze liczby od 0 do 4.
Zmniejszanie wartości:
for(int i = 5; i > 0; i--) {
cout << i << " ";
}
Użycie wielu zmiennych:
for(int i = 0, j = 5; i <= 5 && j >= 0; i++, j--) {
cout << i << "," << j << " ";
}
Pętla nieskończona:
for(;;) {
// Może zostać przerwana przez break.
}
Iteracja przez tablicę:
int arr[] = {1, 2, 3, 4, 5};
for(int i = 0; i < sizeof(arr)/sizeof(arr[0]); i++) {
cout << arr[i] << " ";
}
Pętla zakresowa for (C++11 i nowsze)
Pętla zakresowa
for umożliwia iterowanie po elementach kontenera (takiego jak tablice czy kontenery STL) bez konieczności używania indeksów lub iteratorów.
Przykład:
int arr[] = {1, 2, 3, 4, 5};
for(int x : arr) {
cout << x << " ";
}
Wypisze wszystkie elementy tablicy: 1 2 3 4 5.
Pętla while
Pętla
while kontynuuje wykonywanie instrukcji wewnątrz pętli, dopóki warunek jest prawdziwy. Jest szczególnie przydatna, gdy liczba iteracji nie jest znana przed rozpoczęciem pętli.
Przykłady:
int i = 0;
while(i < 5) {
cout << i << " ";
i++;
}
Również wypisze liczby od 0 do 4.
Sprawdzanie warunku przed pętlą:
int j = 5;
while(j > 0) {
cout << j << " ";
j--;
}
Nieskończona pętla:
while(true) {
// Może zostać przerwana przez break.
}
Czekanie na spełnienie warunku:
int k = 10;
while(k > 5) {
k--;
// Czeka, aż k będzie mniejsze lub równe 5.
}
Zliczanie w dół:
int l = 5;
while(l--) {
cout << l << " ";
}
Pętla do-while
Pętla
do-while jest podobna do pętli
while, ale zapewnia, że ciało pętli zostanie wykonane co najmniej raz, ponieważ warunek jest sprawdzany po wykonaniu instrukcji wewnątrz pętli.
Przykłady:
int i = 0;
do {
cout << i << " ";
i++;
} while(i < 5);
Także wypisze liczby od 0 do 4, ale warunek jest sprawdzany po pierwszej iteracji.
Wykonanie kodu przynajmniej raz:
int n = 5;
do {
cout << n << " ";
} while(false);
Nieskończona pętla:
do {
// Wykonaj coś niekończącego się.
} while(true);
Interakcja z użytkownikiem:
char cont = 'n';
do {
cout << "Czy kontynuować? (y/n): ";
cin >> cont;
} while(cont == 'y');
Zliczanie w górę z warunkiem zewnętrznym:
int o = 0;
do {
cout << o << " ";
o++;
} while(o < 3);
break i continue
break jest używane do natychmiastowego wyjścia z pętli, niezależnie od jej warunku kontynuacji. Może być używane w każdym typie pętli.
Przykład z break:
for(int i = 0; i < 10; i++) {
if(i == 5) break; // Wyjdź z pętli, gdy i osiągnie 5.
cout << i << " ";
}
Wypisze liczby od 0 do 4.
continue pomija pozostałą część kodu w bieżącej iteracji pętli i przechodzi do kolejnej iteracji. Również może być używane w każdym typie pętli.
Przykład z continue:
for(int i = 0; i < 10; i++) {
if(i == 5) continue; // Pomija resztę kodu w tej iteracji dla i == 5.
cout << i << " ";
}
Wypisze liczby od 0 do 4 oraz od 6 do 9, pomijając 5.
Obie instrukcje,
break i
continue, zapewniają dodatkową kontrolę nad przepływem pętli, umożliwiając bardziej złożone zachowania, takie jak przedwczesne zakończenie iteracji lub pominięcie określonych przypadków bez konieczności wyjścia z pętli.
Pętle zagnieżdżone w C++
Pętle zagnieżdżone w C++ to struktury, w których jedna pętla (wewnętrzna) jest umieszczona wewnątrz innej pętli (zewnętrznej). Umożliwiają one wykonywanie bardziej złożonych operacji iteracyjnych, takich jak przeglądanie elementów wielowymiarowych struktur danych (np. tablic wielowymiarowych), generowanie wzorów lub wykonanie obliczeń wymagających wielokrotnego zagnieżdżenia.
Przykłady użycia pętli zagnieżdżonych:
Iteracja przez tablicę dwuwymiarową
Użycie pętli zagnieżdżonych do wyświetlenia elementów tablicy dwuwymiarowej:
#include <iostream>
using namespace std;
int main() {
int tablica[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
for(int i = 0; i < 3; i++) { // Zewnętrzna pętla dla wierszy
for(int j = 0; j < 4; j++) { // Wewnętrzna pętla dla kolumn
cout << tablica[i][j] << " ";
}
cout << endl;
}
return 0;
}
Generowanie tabliczki mnożenia
Wydrukowanie tabliczki mnożenia do 10 za pomocą pętli zagnieżdżonych:
#include <iostream>
using namespace std;
int main() {
for(int i = 1; i <= 10; i++) {
for(int j = 1; j <= 10; j++) {
cout << i * j << "\t";
}
cout << endl;
}
return 0;
}
Rysowanie wzoru
Użycie pętli zagnieżdżonych do rysowania prostego wzoru (np. prostokąta z gwiazdek):
#include <iostream>
using namespace std;
int main() {
int szerokosc = 5, wysokosc = 4;
for(int i = 0; i < wysokosc; i++) {
for(int j = 0; j < szerokosc; j++) {
cout << "* ";
}
cout << endl;
}
return 0;
}
Wyszukiwanie elementu w tablicy dwuwymiarowej
Sprawdzenie, czy dany element znajduje się w tablicy dwuwymiarowej:
#include <iostream>
using namespace std;
int main() {
int tablica[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
int szukana = 7;
bool znaleziono = false;
for(int i = 0; i < 3 && !znaleziono; i++) {
for(int j = 0; j < 4; j++) {
if(tablica[i][j] == szukana) {
znaleziono = true;
break; // Przerwanie wewnętrznej pętli
}
}
}
if(znaleziono) {
cout << "Znaleziono element: " << szukana << endl;
} else {
cout << "Nie znaleziono elementu: " << szukana << endl;
}
return 0;
}
Zagnieżdżone pętle i logika break/continue
Użycie
break i
continue w zagnieżdżonych pętlach do kontroli przepływu:
#include <iostream>
using namespace std;
int main() {
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
if (j == 2) {
// Pomija resztę kodu w pętli dla j == 2
continue;
}
cout << "i = " << i << ", j = " << j << endl;
if (i == 2) {
// Przerwanie wewnętrznej pętli dla i == 2
break;
}
}
}
return 0;
}
