Pętle

Pętla jest konstrukcją sterującą umożliwiającą wielokrotne wykonanie tego samego fragmentu kodu przy spełnieniu określonego warunku. Bez pętli większość praktycznych programów byłaby nieefektywna lub wręcz niemożliwa do zapisania w rozsądnej formie. Mechanizm ten pozwala przetwarzać tablice, wykonywać obliczenia iteracyjne, analizować dane wejściowe oraz implementować algorytmy numeryczne i kombinatoryczne. W kontekście podstaw języków niskiego i średniego poziomu szczególnie istotne są Pętle C/C++ i ich rodzaje wstęp do programowania.

Pętle w programowaniu jako fundament iteracyjnego przetwarzania danych i kontroli przepływu

W modelu wykonania programu instrukcje wykonywane są sekwencyjnie, od góry do dołu. Pętla w programowaniu wprowadza możliwość powrotu do wcześniejszej instrukcji bez używania instrukcji skoku bezwarunkowego (np. goto). Z punktu widzenia teorii obliczeń pętla realizuje mechanizm iteracji, który wraz z instrukcją warunkową wystarcza do osiągnięcia zupełności Turinga.

Pętla składa się z:

  1. Warunku logicznego (predykatu),
  2. Ciała pętli (bloku instrukcji),
  3. Mechanizmu zmiany stanu wpływającego na warunek.

W praktyce najczęściej występują trzy podstawowe rodzaje:

  • while
  • do...while
  • for

Każda z nich różni się momentem sprawdzania warunku oraz sposobem zapisu inicjalizacji i kroku iteracyjnego.

Iteracja oznacza jedno przejście przez ciało pętli. Jeśli warunek pozostaje zawsze prawdziwy, powstaje pętla nieskończona. Jest to zarówno narzędzie (np. w systemach wbudowanych), jak i częsty błąd początkujących.

Pętle C/C++ i ich rodzaje wstęp do programowania – konstrukcja while i kontrola warunku przed wejściem do ciała

Pętla while jest pętlą z warunkiem sprawdzanym przed wykonaniem ciała.

Składnia w C/C++:

while (warunek) {
    instrukcje;
}

Algorytm działania:

  1. Sprawdzenie warunku.
  2. Jeśli warunek jest prawdziwy (różny od zera w C), wykonanie ciała.
  3. Powrót do punktu 1.

Przykład – wypisanie liczb od 0 do 4.

C

#include <stdio.h>int main() {
    int i = 0;    while (i < 5) {
        printf("%d\n", i);
        i++;
    }    return 0;
}

C++

#include <iostream>
using namespace std;int main() {
    int i = 0;    while (i < 5) {
        cout << i << endl;
        i++;
    }    return 0;
}

Python

i = 0while i < 5:
    print(i)
    i += 1

Kluczowa obserwacja: jeśli i nie będzie zwiększane, warunek i < 5 nigdy nie stanie się fałszywy i pętla będzie nieskończona.

Ważna zależność logiczna: zmienna sterująca musi być modyfikowana w taki sposób, aby prowadzić do zakończenia pętli.

Pętle C/C++ i ich rodzaje wstęp do programowania – konstrukcja do…while i gwarancja co najmniej jednej iteracji

Pętla do...while różni się tym, że warunek sprawdzany jest po wykonaniu ciała.

Składnia w C/C++:

do {
    instrukcje;
} while (warunek);

Schemat:

  1. Wykonanie ciała.
  2. Sprawdzenie warunku.
  3. Jeśli prawdziwy – powrót do punktu 1.

Przykład:

#include <stdio.h>int main() {
    int i = 0;    do {
        printf("%d\n", i);
        i++;
    } while (i < 5);    return 0;
}

Różnica względem while pojawia się wtedy, gdy warunek początkowo jest fałszywy. W while ciało nie wykona się ani razu. W do...while wykona się dokładnie raz.

To rozwiązanie jest często stosowane przy wczytywaniu danych, gdzie przynajmniej jedno odczytanie musi nastąpić.

W Pythonie brak bezpośredniego odpowiednika do...while. Symuluje się to poprzez:

while True:
    x = int(input())
    if x >= 0:
        break

Tutaj break zastępuje warunek końcowy.

Pętle C/C++ i ich rodzaje wstęp do programowania – konstrukcja for jako syntetyczne połączenie inicjalizacji, warunku i kroku

Pętla for jest konstrukcją zwartą, w której inicjalizacja, warunek i krok znajdują się w jednym miejscu.

Składnia:

for (inicjalizacja; warunek; krok) {
    instrukcje;
}

Rozpisanie logiczne:

inicjalizacja;
while (warunek) {
    instrukcje;
    krok;
}

Przykład – suma liczb od 1 do 5.

C

#include <stdio.h>int main() {
    int suma = 0;    for (int i = 1; i <= 5; i++) {
        suma += i;
    }    printf("Suma = %d\n", suma);    return 0;
}

C++

#include <iostream>
using namespace std;int main() {
    int suma = 0;    for (int i = 1; i <= 5; i++) {
        suma += i;
    }    cout << "Suma = " << suma << endl;    return 0;
}

Python

suma = 0for i in range(1, 6):
    suma += iprint("Suma =", suma)

W Pythonie for działa inaczej semantycznie – iteruje po sekwencji, a nie w klasycznym sensie warunkowym. Jednak w podstawowych zastosowaniach pełni tę samą funkcję.

Pętle: programowanie a zależność między warunkiem logicznym i typem danych

W językach C/C++ warunek pętli jest wyrażeniem całkowitoliczbowym. Wartość 0 oznacza fałsz, każda inna – prawdę. To ma konsekwencje:

while (x) {
    ...
}

Jeśli x jest typu int, pętla działa dopóki x != 0.

Częsty błąd:

while (x = 5) {
    ...
}

To jest przypisanie, nie porównanie. Warunek zawsze jest prawdziwy (bo 5 ≠ 0). Powstaje pętla nieskończona.

Poprawnie:

while (x == 5) {
    ...
}

W Pythonie nie ma takiego problemu, ponieważ przypisanie nie jest wyrażeniem logicznym.

Pętle: php w kontekście składni i podobieństw do C

W PHP konstrukcje pętli są niemal identyczne jak w C.

Przykład while w PHP:

<?php
$i = 0;while ($i < 5) {
    echo $i . "\n";
    $i++;
}
?>

Przykład for:

<?php
for ($i = 0; $i < 5; $i++) {
    echo $i . "\n";
}
?>

PHP również posiada do...while.

Różnica polega głównie na dynamicznym typowaniu. Warunek jest rzutowany na wartość logiczną zgodnie z zasadami języka PHP.

Pętle zagnieżdżone i ich znaczenie w algorytmach dwuwymiarowych

Pętla zagnieżdżona to pętla wewnątrz innej pętli.

Przykład – tabliczka mnożenia 3×3 w C:

#include <stdio.h>int main() {
    for (int i = 1; i <= 3; i++) {
        for (int j = 1; j <= 3; j++) {
            printf("%d ", i * j);
        }
        printf("\n");
    }    return 0;
}

Liczba iteracji całkowita to iloczyn liczby iteracji obu pętli. Jeśli obie mają zakres n, złożoność wynosi O(n²).

To bezpośrednio łączy temat pętli z analizą złożoności czasowej algorytmów.

Instrukcje break i continue jako mechanizmy modyfikujące przebieg iteracji

break – natychmiastowe wyjście z pętli.
continue – pominięcie reszty ciała i przejście do następnej iteracji.

Przykład:

for (int i = 0; i < 10; i++) {
    if (i == 5)
        break;    printf("%d\n", i);
}

Program wypisze 0–4.

continue:

for (int i = 0; i < 5; i++) {
    if (i == 2)
        continue;    printf("%d\n", i);
}

Wynik: 0, 1, 3, 4.

Nadużywanie break i continue może obniżyć czytelność kodu, szczególnie w pętlach zagnieżdżonych.

Typowe pułapki związane z pętlami i błędy logiczne początkujących

  1. Pętla nieskończona przez brak zmiany zmiennej sterującej.
  2. Błąd zakresu (off-by-one), np. i <= n zamiast i < n.
  3. Modyfikowanie zmiennej sterującej w kilku miejscach.
  4. Używanie typu float w warunku zakończenia – błędy zaokrągleń.
  5. Przekroczenie zakresu tablicy w pętli.

Przykład błędu:

for (int i = 0; i <= 10; i++) {
    tab[i] = 0;
}

Jeśli tablica ma rozmiar 10, poprawny zakres to 0–9.

Zależność między pętlą a złożonością obliczeniową algorytmu

Jedna pętla liniowa → O(n)
Dwie zagnieżdżone → O(n²)
Trzy → O(n³)

Zrozumienie tej zależności jest kluczowe przy analizie wydajności.

Przykład: wyszukiwanie liniowe to pojedyncza pętla – O(n).
Sortowanie bąbelkowe – dwie pętle zagnieżdżone – O(n²).

Pętla nie jest tylko konstrukcją składniową. Jest bezpośrednim odzwierciedleniem kosztu obliczeniowego.

Uwagi praktyczne

  • Zawsze analizować warunek zakończenia przed uruchomieniem programu.
  • Unikać skomplikowanych warunków logicznych w nagłówku pętli.
  • W C/C++ pilnować różnicy między = i ==.
  • W algorytmach numerycznych unikać warunku while (x != 0.0).
  • W pętlach zagnieżdżonych kontrolować złożoność.

Pętla jest jedną z podstawowych konstrukcji sterujących i bez jej zrozumienia nie da się pisać poprawnych algorytmów. W praktyce większość operacji na danych to iteracja w różnych wariantach, a poprawne opanowanie mechaniki działania pętli przekłada się bezpośrednio na jakość i wydajność programów.