Pętla while C, PHP. i do...while

Pętla while jest jedną z podstawowych instrukcji sterujących przepływem programu. Służy do wielokrotnego wykonywania fragmentu kodu tak długo, jak długo określony warunek logiczny ma wartość prawda. W przeciwieństwie do pętli for nie wymaga z góry znanej liczby iteracji – decyzja o zakończeniu wykonania zależy wyłącznie od warunku sprawdzanego przed każdą kolejną iteracją. Mechanizm ten jest prosty w budowie, ale bardzo elastyczny w zastosowaniu, dlatego Pętla while stanowi fundament wielu algorytmów iteracyjnych.

Spis treści

Pętla while – składnia, semantyka działania i najprostszy przykład użycia

Każda pętla while składa się z dwóch elementów:

Słowa kluczowego while
Warunku logicznego umieszczonego w nawiasach okrągłych

Ogólna postać:

while (warunek) {
    instrukcje;
}

Zasada działania jest następująca:

Sprawdzany jest warunek.
Jeśli warunek jest prawdziwy (true), wykonywane jest ciało pętli.
Po wykonaniu ciała pętli program wraca do punktu sprawdzenia warunku.
Gdy warunek stanie się fałszywy (false), pętla kończy działanie.

Kluczowe jest to, że warunek sprawdzany jest przed wykonaniem ciała pętli. Jeśli już na początku jest fałszywy, kod wewnątrz nie wykona się ani razu.

Najprostszy przykład – wypisanie liczb od 1 do 5

C (while C)

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

C++ (while cpp)

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

Python

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

Schemat działania jest identyczny:

inicjalizacja zmiennej sterującej,
warunek zakończenia,
modyfikacja zmiennej w ciele pętli.

Jeżeli zapomnimy o inkrementacji i, warunek nigdy nie stanie się fałszywy i powstanie pętla nieskończona.

Pętla while – analiza mechanizmu warunku, kontrola przepływu i różnice względem for

Warunek w pętli while jest wyrażeniem logicznym. Może być:

prostym porównaniem (i < 10)
złożonym wyrażeniem logicznym (i < 10 && suma != 0)
sprawdzeniem wartości logicznej zmiennej (while (flaga))

W językach takich jak C czy C++ każde wyrażenie liczbowe może być interpretowane logicznie:

0 → fałsz
wartość niezerowa → prawda

Przykład:

int x = 5;while (x) {
    printf("%d\n", x);
    x--;
}

Pętla wykona się dopóki x jest różne od zera.

Różnice względem pętli for

Pętla for ma postać:

for (inicjalizacja; warunek; modyfikacja)

Natomiast while rozdziela te elementy:

inicjalizacja przed pętlą,
warunek w nagłówku,
modyfikacja w ciele.

W praktyce każdą pętlę for można zapisać jako while:

for (int i = 0; i < 10; i++)

jest równoważne:

int i = 0;
while (i < 10) {
    i++;
}

Pętla while jest wygodniejsza, gdy:

liczba iteracji nie jest znana,
zakończenie zależy od zdarzenia (np. wczytywania danych),
warunek ma charakter dynamiczny.

Pętla while – zastosowania w algorytmach iteracyjnych i przetwarzaniu danych wejściowych

Wczytywanie danych do momentu spełnienia warunku

Typowy przypadek:

użytkownik podaje liczby,
program kończy wczytywanie po wpisaniu zera.

C

#include <stdio.h>int main() {
    int liczba;
    int suma = 0;    scanf("%d", &liczba);    while (liczba != 0) {
        suma += liczba;
        scanf("%d", &liczba);
    }    printf("Suma: %d\n", suma);    return 0;
}

Tutaj nie znamy liczby iteracji. Pętla działa dopóki warunek jest spełniony.

Algorytmy numeryczne

Przykład: przybliżanie pierwiastka metodą Newtona.

Schemat:

zaczynamy od przybliżenia,
iterujemy aż różnica między kolejnymi przybliżeniami będzie mała.

Python:

x = 2.0
eps = 0.0001
a = 10.0while abs(x * x - a) > eps:
    x = 0.5 * (x + a / x)print(x)

Warunek nie zależy od licznika, lecz od dokładności obliczeń.

Pętla do while – różnice względem while do i sytuacje, w których wykonanie ciała musi nastąpić przynajmniej raz

Pętla do while (w niektórych opisach: while do) różni się od klasycznej pętli while kolejnością sprawdzania warunku.

Składnia w C i C++:

do {
    instrukcje;
} while (warunek);

Najważniejsza różnica:

warunek sprawdzany jest po wykonaniu ciała pętli,
ciało wykona się zawsze co najmniej jeden raz.

Przykład – menu użytkownika

#include <stdio.h>int main() {
    int wybor;    do {
        printf("1 - Opcja A\n");
        printf("2 - Opcja B\n");
        printf("0 - Wyjscie\n");
        scanf("%d", &wybor);
    } while (wybor != 0);    return 0;
}

Tutaj pętla do while ma sens, bo menu musi zostać pokazane przynajmniej raz.

W C++ zapis jest identyczny. W Pythonie nie ma wbudowanej konstrukcji pętla do while. Można ją symulować:

while True:
    wybor = int(input("Podaj liczbe (0 konczy): "))
    if wybor == 0:
        break

Warunek zakończenia realizowany jest przez break.

Pętla while php – zastosowanie w przetwarzaniu danych i pracy z bazą danych

W PHP konstrukcja jest taka sama:

<?php
$i = 1;while ($i <= 5) {
    echo $i . "<br>";
    $i++;
}
?>

Częste zastosowanie to przetwarzanie wyników zapytania SQL:

<?php
while ($wiersz = mysqli_fetch_assoc($wynik)) {
    echo $wiersz["nazwa"] . "<br>";
}
?>

Pętla działa dopóki funkcja pobierająca rekord zwraca dane. Gdy zwróci false, warunek przestaje być spełniony.

Typowe błędy logiczne w konstrukcji pętli while i sposoby ich unikania

1. Pętla nieskończona

while (i < 10) {
    printf("%d\n", i);
}

Brak zmiany i.

Rozwiązanie: zawsze sprawdzić, czy zmienna wpływająca na warunek jest modyfikowana.

2. Błąd off-by-one

while (i <= 10)

Zamiast:

while (i < 10)

Trzeba jasno określić, czy zakres jest domknięty czy półotwarty.

3. Warunek zależny od danych wejściowych bez walidacji

Jeśli dane nie zmienią warunku, pętla może działać w nieskończoność.

4. Modyfikacja zmiennej w niewłaściwym miejscu

Zmiana warunku powinna być jednoznaczna i czytelna. Rozproszenie logiki utrudnia analizę poprawności.

Zastosowania pętli while w implementacji struktur i algorytmów

Pętla while jest podstawą:

przeszukiwania list jednokierunkowych,
przechodzenia po drzewach (w wersji iteracyjnej),
implementacji algorytmów BFS i DFS,
algorytmów typu „dopóki nie spełniono kryterium”.

Przykład – przejście po liście jednokierunkowej (C):

struct Node {
    int value;
    struct Node* next;
};void printList(struct Node* head) {
    struct Node* current = head;    while (current != NULL) {
        printf("%d\n", current->value);
        current = current->next;
    }
}

Warunek kończy pętlę po dojściu do wskaźnika NULL.

Krótkie uwagi praktyczne dotyczące projektowania warunków zakończenia

Warunek powinien być prosty i jednoznaczny.
Zmienna sterująca powinna być widoczna w jednym miejscu.
W algorytmach numerycznych należy uwzględniać tolerancję błędu.
W przypadku danych zewnętrznych (plik, sieć, baza danych) trzeba uwzględnić możliwość błędu odczytu.

Dobrą praktyką jest mentalne prześledzenie pierwszych trzech iteracji oraz sprawdzenie, w którym momencie warunek stanie się fałszywy.

Pętla while oraz jej odmiana pętla do while należą do najbardziej podstawowych, a jednocześnie najbardziej elastycznych konstrukcji sterujących. Zrozumienie dokładnej kolejności sprawdzania warunku i modyfikacji stanu programu jest kluczowe dla poprawnego projektowania algorytmów iteracyjnych i unikania błędów logicznych.