W najprostszej postaci pętla for w języku C++ wygląda tak:

for (int i = początek; i <= koniec; i++)
    instrukcja;

W pętli deklarujemy zmienną całkowitą, którą nazwaliśmy \(i\). Jest ona zmienną sterującą pętli. Zmienna ta przemierza kolejno wszystkie wartości od początek do koniec (gdzie początek i koniec może być liczbą, zmienną lub ogólnie wyrażeniem arytmetycznym). Dla każdej z tych wartości po kolei wykonywana jest instrukcja wewnątrz pętli. Podobnie jak poprzednio, może to być albo pojedyncza instrukcja, albo instrukcja złożona umieszczona w nawiasach klamrowych.

W poprzedniej lekcji napisaliśmy program, który wypisywał kolejno liczby od 1 do 10. Za pomocą pętli for możemy go napisać krócej:

#include <iostream>
using namespace std;
 
int main() {
    for (int i = 1; i <= 10; i++)
        cout << i << endl;
}

I jeszcze jeden przykład – program wczytujący liczbę całkowitą \(n\) i wyznaczający \(n\)-tą liczbę trójkątną, czyli sumę liczb od 1 do \(n\). Używamy w nim zmiennej pomocniczej \(suma\).

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

Pętla w powyższym programie zastępuje więc serię instrukcji postaci:

suma += 1;
suma += 2;
...
suma += n;

Opowiedzmy jeszcze trochę o innych wariantach pętli for. Pętla ta składa się z trzech części, rozdzielonych średnikami. W pierwszej podajemy początkową wartość zmiennej sterującej. W trzeciej znajduje się krok pętli, czyli informacja, jak ma się zmieniać wartość zmiennej sterującej. Zazwyczaj ma ona każdorazowo wzrastać lub maleć o 1 lub o jakąś większą wartość. Druga część wreszcie zawiera warunek logiczny, którego niespełnienie powoduje zakończenie pętli. Warunek ten sprawdzamy na początku – jeśli od początku nie jest spełniony, pętla nie wykona się ani razu – jak i po każdym wykonaniu kroku pętli. Zmienną sterującą pętli zwyczajowo nazwaliśmy \(i\), ale ogólnie dobór nazwy tej zmiennej może być dowolny.

Przykładowo, gdybyśmy chcieli wypisać wszystkie liczby parzyste od 20 do 0, jak w poprzedniej lekcji, za pomocą pętli for napisalibyśmy tak:

for (int i = 20; i >= 0; i -= 2)
    cout << i << endl;

W poprzedniej lekcji napisaliśmy program, który najpierw wczytuje liczbę \(n\), następnie \(n\) liczb całkowitych, po czym wypisuje sumę tych \(n\) liczb. Zróbmy to samo, tylko z użyciem pętli for:

#include <iostream>
using namespace std;
 
int main() {
    int n;
    cin >> n;
    int suma = 0;
    for (int i = 1; i <= n; i++) {
        int a;
        cin >> a;
        suma += a;
    }
    cout << suma << endl;
}

W ten sposób każdą z \(n\) liczb na wejściu wczytaliśmy do tej samej zmiennej \(a\). Teraz opowiemy o innej konstrukcji programistycznej, który pozwoli przechowywać wszystkie wczytane liczby naraz. Są to tablice.

Tablicę liczb całkowitych deklarujemy w języku C++ tak:

int tablica[dlugosc];

W ten sposób zadeklarowaliśmy tablicę o nazwie tablica, która składa się z elementów będących liczbami całkowitymi. Liczbę tych elementów określa długość (rozmiar) tablicy.

Nazwy tablic możemy dobierać dowolnie, tak jak nazwy zmiennych. Długość tablicy jest najczęściej jedną liczbą, pojedynczą zmienną (odpowiadającą np. długości ciągu liczb) albo prostym wyrażeniem arytmetycznym. Przykładowo:

int t[n];

to tablica o nazwie \(t\) zawierająca \(n\) elementów.

Elementy takiej tablicy to: \(t[0],t[1],\ldots,t[n-1]\). Widzimy, że numerujemy je począwszy od zera. Każdy z elementów odpowiada osobnemu miejscu w pamięci komputera, w którym jest zapamiętana jedna liczba – jest to to samo, co \(n\) zmiennych całkowitych naraz!

Przepiszemy nasz poprzedni program z użyciem tablicy. Ponieważ elementy tablicy numerujemy od zera, więc zmienna sterująca \(i\) będzie tym razem przyjmować wartości \(0,1,\ldots,n-1\):

#include <iostream>
using namespace std;
 
int main() {
    int n;
    cin >> n;
    int t[n];
    int suma = 0;
    for (int i = 0; i < n; i++) {
        cin >> t[i];
        suma += t[i];
    }
    cout << suma << endl;
}

W tym przykładzie nie było żadnej potrzeby, żeby przechowywać wczytane liczby w tablicy. Dzięki niej możemy jednak najpierw wczytać wszystkie dane, a dopiero potem wykonać żądane obliczenia – a tak się po prostu łatwiej myśli. Możemy też obliczyć coś jeszcze dla tych samych danych, np. minimum w tablicy:

#include <iostream>
using namespace std;
 
int main() {
    int n;
    cin >> n;
    int t[n];
    int suma = 0;
    for (int i = 0; i < n; i++)
        cin >> t[i];

    int suma = 0;
    for (int i = 0; i < n; i++)
        suma += t[i];
    cout << suma << endl;

    int min = t[0];
    for (int i = 1; i < n; i++)
        if (t[i] < min)
            min = t[i];
    cout << min << endl;
}

Inny przykład to program, w którym wczytujemy ciąg liczb o długości \(n\) i chcemy go wypisać od ostatniej liczby do pierwszej. Tego zadania nie da się już rozwiązać bez użycia tablic:

#include <iostream>
using namespace std;
 
int main() {
    int n;
    cin >> n;
    int t[n];
    for (int i = 0; i < n; i++)
        cin >> t[i];
    for (int i = n - 1; i >= 0; i--)
        cout << t[i] << " ";
    cout << endl;
}

for (instrukcja_początkowa; warunek_stopu; krok_pętli)
    instrukcja;

instrukcja_początkowa;
sprawdź warunek_stopu - jeśli fałszywy, to koniec
instrukcja;
krok_pętli;
sprawdź warunek_stopu - jeśli fałszywy, to koniec
instrukcja;
krok_pętli;
...

#include <iostream>
using namespace std;
 
int main() {
    int n;
    cin >> n;
    int liczba_cyfr = 0;
    if (n == 0)
        liczba_cyfr = 1;
    else
        for (; n > 0; n /= 10)
            liczba_cyfr++;
    cout << liczba_cyfr << endl;
}

Skorzystajmy z tablicy, w której będziemy przechowywać kolejne liczby Fibonacciego. Piszemy i uruchamiamy poniższy program:

#include <iostream>

using namespace std;

int main()
{
    int fib[50];
    fib[0] = 0;
    fib[1] = 1;
    for (int i = 2; i <= 50; i++)
        fib[i] = fib[i - 1] + fib[i - 2];
    cout << fib[50] << endl;
}

Niestety w wyniku działania programu nie otrzymujemy żadnej liczby, a tylko komunikat, że program skończył się z błędem. Jest to tzw. błąd wykonania. Pierwszy przykład błędu wykonania mieliśmy już w lekcji drugiej, gdy w programie wykonującym dzielenie wprowadziliśmy dzielnik równy 0. W tym programie jest inna usterka, która powoduje ten błąd. Otóż wychodzimy indeksem poza tablicę. Rzeczywiście, tablica \(fib\) składa się z elementów \(fib[0],\ldots,fib[49]\), a my zarówno w pętli dla \(i=50\), jak i w ostatniej instrukcji korzystamy z pola \(fib[50]\).

Wyjście indeksem poza tablicę (czy też w stronę ujemnych indeksów, czy też ponad rozmiar) jest częstą i zarazem kłopotliwą usterką. Może powodować niezdefiniowane działanie programu: błąd wykonania, błędną odpowiedź, a czasem nawet, jeśli nam się poszczęści, wynik programu jest poprawny. Jest to ponadto niedeterministyczne: program może działać inaczej na jednym komputerze, a inaczej na innym. Dlatego wielu programistów, zwłaszcza w programach pisanych na szybko, wpisuje zawsze rozmiar tablicy o kilka elementów większy niż rozmiar ściśle wymagany – właśnie na wypadek własnego przeoczenia. W naszym przypadku wystarczy wpisać rozmiar 51:

#include <iostream>

using namespace std;

int main()
{
    int fib[51];
    fib[0] = 0;
    fib[1] = 1;
    for (int i = 2; i <= 50; i++)
        fib[i] = fib[i - 1] + fib[i - 2];
    cout << fib[50] << endl;
}

Gdy uruchomimy ten poprawiony program, otrzymujemy w wyniku liczbę:

-298632863

Jest to wynik ewidentnie błędny, gdyż wszystkie liczby Fibonacciego są nieujemne. Co tym razem poszło nie tak? W poprzedniej lekcji, mierząc się z podobnym problemem, wykorzystaliśmy dodatkowe wypisywania. Zróbmy tak samo teraz:

#include <iostream>

using namespace std;

int main()
{
    int fib[51];
    fib[0] = 0;
    fib[1] = 1;
    for (int i = 2; i <= 50; i++) {
        fib[i] = fib[i - 1] + fib[i - 2];
        cout << i << " " << fib[i] << endl;
    }
    cout << fib[50] << endl;
}

Wyniki programu do pewnego momentu wyglądają rozsądnie, ale gdzieś między 40-tym a 50-tym elementem zaczynają pojawiać się liczby ujemne:

2 1
3 2
4 3
5 5
6 8
7 13
8 21
9 34
...
36 14930352
37 24157817
38 39088169
39 63245986
40 102334155
41 165580141
42 267914296
43 433494437
44 701408733
45 1134903170
46 1836311903
47 -1323752223
48 512559680
49 -811192543
50 -298632863
-298632863

Zauważmy, że 46-ta liczba Fibonacciego jest równa prawie \(2 \cdot 10^9\), czyli ledwie mieści się w zakresie typu int. Kolejne liczby po prostu wychodzą już poza zakres, co objawia się ujemnymi (oraz bezsensownymi dodatnimi) wartościami. W tym przypadku wystarczy zmienić typ elementów tablicy na jakiś 64-bitowy, np. long long:

#include <iostream>

using namespace std;

int main()
{
    long long fib[51];
    fib[0] = 0;
    fib[1] = 1;
    for (int i = 2; i <= 50; i++) {
        fib[i] = fib[i - 1] + fib[i - 2];
        cout << i << " " << fib[i] << endl;
    }
    cout << fib[50] << endl;
}

Dzięki temu już wiemy, jaka jest 50-ta liczba Fibonacciego:

...
40 102334155
41 165580141
42 267914296
43 433494437
44 701408733
45 1134903170
46 1836311903
47 2971215073
48 4807526976
49 7778742049
50 12586269025
12586269025

Błąd przekroczenia zakresu zmiennej jest kolejnym typowym błędem popełnianym przez programistów. W tym przypadku wystąpił on dlatego, że liczby Fibonacciego naprawdę szybko rosną. Jeśli nasz program nie działa, dobrze jest sprawdzić kod pod kątem tego typu błędów – zwłaszcza jeśli w programie wykonujemy np. wiele mnożeń.