C++ · Podstawy · Lekcja 01

Typy zmiennych w C++

Lekcja dla zupełnie początkujących — spokojnie, krok po kroku i z mnóstwem przykładów. Napiszesz pierwszy program, poznasz zmienne, wczytywanie danych i wszystkie podstawowe typy: int, double, char, string, bool i long long. Po każdej części czekają ćwiczenia z automatyczną sprawdzarką.

48 ćwiczeń w trakcie lekcji26 zadań w bazie na koniec74 ze sprawdzarką C++
Filmy z OKI

Wolisz obejrzeć?

Olimpijskie Koło Informatyczne nagrywa swoje zajęcia i udostępnia je za darmo. Poniżej 3 odcinki o tym temacie — dobre uzupełnienie, jeśli wolisz obejrzeć niż przeczytać.

Materiały Olimpijskiego Koła Informatycznego — kanał zewnętrzny. Kliknięcie odtwarza film tutaj, bez opuszczania strony.

Jak uczyć się z tej lekcji

Ta lekcja zakłada, że nigdy wcześniej nie programowałeś. Potrzebujesz tylko działającego środowiska z lekcji Setup: edytora, w którym piszesz kod, i kompilatora, który zamienia ten kod w program. Wszystko inne wyjaśniamy od zera — powoli i na wielu przykładach.

Lekcja ma jedenaście części. Każda kończy się szybkimi pytaniami „Co wypisze program?” i blokiem ćwiczeń, które od razu sprawdzisz w automatycznej sprawdzarce. Na samym końcu czeka baza zadań na cały temat — od bardzo łatwych do naprawdę podchwytliwych.

KROK 1

Czytaj i przepisuj

Każdy przykład przepisz do swojego edytora i uruchom. Nie kopiuj — przepisuj. Ręce uczą się razem z głową, a literówki, które przy tym zrobisz, nauczą Cię czytać komunikaty kompilatora.

KROK 2

Zgaduj, zanim sprawdzisz

Przy pytaniach „Co wypisze program?” najpierw odpowiedz w głowie albo na kartce, a dopiero potem odkryj odpowiedź. Pomyłka to najlepsza lekcja — pod warunkiem, że wiesz, gdzie się pomyliłeś.

KROK 3

Rób ćwiczenia

Po każdej części rozwiąż ćwiczenia w sprawdzarce. Nie idź dalej, dopóki nie zrobisz przynajmniej łatwych — kolejne części budują na poprzednich.

KROK 4

Baza zadań na koniec

Gdy skończysz lekcję, przerób bazę zadań po kolei. Zadania są ułożone od najłatwiejszego, a przy każdym widać, jakich zagadnień używa.

Jak działa sprawdzarka?

Każde ćwiczenie otwiera się na stronie Zadania tematami. Znajdziesz tam treść zadania, opis wejścia i wyjścia, przykłady i wskazówkę, a pod spodem — pole na kod. Wklejasz cały program, klikasz Wyślij, a sprawdzarka kompiluje go i uruchamia na kilku–kilkunastu testach. Po chwili dostajesz werdykt dla każdego testu:

WerdyktCo znaczyCo zrobić
AcceptedWszystkie testy przeszły — zadanie zaliczone.Brawo! Bierz następne.
Wrong answerProgram działa, ale wypisał coś innego, niż trzeba.Porównaj swoje wyjście z oczekiwanym — sprawdzarka pokazuje oba obok siebie.
Compilation errorKod się nie skompilował: literówka, brak średnika albo klamry.Przeczytaj komunikat — podaje numer linii z błędem.
Runtime errorProgram przerwał działanie w trakcie.W tej lekcji to rzadkość — zwykle oznacza dzielenie przez zero.
Time limit exceededProgram liczył za długo.W tej lekcji praktycznie się nie zdarza.
Złota zasada sprawdzarki Sprawdzarka to nie człowiek. Nie przeczyta zdania „Podaj liczbę:” i nie domyśli się, o co Ci chodziło — porównuje Twoje wyjście z oczekiwanym znak po znaku. Wypisuj dokładnie to, o co prosi zadanie: bez dodatkowych zdań, bez zaproszeń do wpisania danych i bez polskich liter.
zle.cpp — Wrong answer
int n;
cout << "Podaj liczbe: ";
cin >> n;
cout << "Podwojona liczba to " << n * 2;
▶ Wyjście dla wejścia 21 — zła odpowiedź
Podaj liczbe: Podwojona liczba to 42
dobrze.cpp — Accepted
int n;
cin >> n;
cout << n * 2 << "\n";
▶ Wyjście dla wejścia 21 — dobra odpowiedź
42

Nie przejmuj się, że jeszcze nie znasz cin — wyjaśnimy je w części 03. Wróć do tego przykładu, gdy dostaniesz pierwsze „Wrong answer”.

Mapa lekcji

Szkielet programu i wypisywanie tekstu

Program to przepis dla komputera: lista poleceń, które komputer wykonuje po kolei, od góry do dołu — jedno po drugim, bez pomijania i bez zgadywania, co autor miał na myśli. Zaczniemy od najprostszego programu na świecie: takiego, który wypisuje na ekran jedno słowo.

📚

#include <iostream>

„Dołącz bibliotekę do wypisywania i wczytywania”. Nazwa iostream to skrót od input/output stream. Bez tej linijki komputer nie zna cout ani cin.

🏷️

using namespace std;

Pozwala pisać krótko cout zamiast std::cout. Wszystkie narzędzia z biblioteki standardowej mają „nazwisko” std — ta linijka mówi: „używam rodziny std, nie musisz mi tego przypominać”.

▶️

int main() { … }

Główna część programu. Komputer zaczyna od pierwszej linijki wewnątrz klamer { } i idzie w dół. Wszystko, co piszesz w tej lekcji, wstawiasz między te klamry.

🏁

return 0;

Ostatnia linijka main: „program zakończył się poprawnie”. Zero oznacza, że wszystko poszło dobrze.

pierwszy.cpp
#include <iostream>
using namespace std;

int main() {
    cout << "Czesc!";
    return 0;
}
▶ Wyjście programu
Czesc!
Na razie — formułka Pierwsze dwie linijki i ramkę z main pisz na razie jak formułkę, zawsze tak samo — tak jak list zawsze zaczyna się od powitania. Zmieniać będziesz tylko to, co jest w środku klamer.

cout — wypisywanie na ekran

cout (czytaj: „si-aut”, od console output) to ekran. Strzałki << pokazują kierunek: to, co stoi po ich prawej stronie, płynie do cout, czyli na ekran. Tekst, który ma się pojawić dokładnie tak, jak go napisałeś, zamykasz w cudzysłowie: "Czesc!".

Każde polecenie kończy się średnikiem ;. Średnik jest jak kropka na końcu zdania — bez niego komputer nie wie, gdzie kończy się jedno polecenie, a zaczyna drugie.

Nowa linia: "\n" i endl

cout nie przechodzi sam do nowej linii. Jeśli napiszesz dwa cout jeden pod drugim, napisy skleją się w jeden wiersz:

bez_nowej_linii.cpp
cout << "Ala";
cout << "ma kota";
▶ Wyjście programu
Alama kota
z_nowa_linia.cpp
cout << "Ala\n";
cout << "ma kota\n";
▶ Wyjście programu
Ala ma kota

"\n" to specjalny znak „przejdź do nowej linii”. Wygląda jak dwa znaki (backslash i literka n), ale dla komputera to jeden znak. Zamiast niego możesz pisać endl — działa tak samo: cout << "Ala" << endl;. W tej lekcji używamy "\n", bo jest krótsze.

Tekst czy działanie? Cudzysłów robi różnicę

Komputer to świetny kalkulator. Jeśli napiszesz działanie bez cudzysłowu, policzy je i wypisze wynik. Jeśli w cudzysłowie — wypisze je jako zwykły tekst, niczego nie licząc.

tekst_czy_liczba.cpp
cout << "2 + 3" << "\n";   // tekst w cudzysłowie: wypisze dokładnie 2 + 3
cout << 2 + 3 << "\n";     // działanie bez cudzysłowu: wypisze wynik
cout << 7 * 6 << "\n";     // gwiazdka * to mnożenie
cout << "Wynik: " << 2 + 3 << "\n";   // tekst i liczba w jednym cout
▶ Wyjście programu
2 + 3 5 42 Wynik: 5

Ostatnia linijka pokazuje, że jednym cout możesz wypisać wiele rzeczy naraz — wystarczy dokładać kolejne <<. Zwróć uwagę na spację po dwukropku: jest w cudzysłowie, więc zostanie wypisana. Gdyby jej nie było, dostałbyś Wynik:5. Komputer nigdy nie wstawia spacji sam od siebie.

Tekst po // to komentarz — notatka dla człowieka. Komputer ją pomija, więc możesz pisać w niej, co chcesz (nawet po polsku).

Znaki specjalne

Backslash \ wewnątrz cudzysłowu zapowiada znak specjalny. Dlatego niektóre znaki zapisuje się w kodzie inaczej, niż wyglądają na ekranie:

Piszesz w cudzysłowieNa ekranie pojawi się
\nprzejście do nowej linii
\\jeden backslash: \
\"cudzysłów: "
\ttabulator (kilka spacji)
Wielkie litery mają znaczenie C++ rozróżnia wielkie i małe litery. cout działa, ale Cout albo COUT to dla komputera zupełnie inne, nieznane słowa — dostaniesz błąd kompilacji. Tak samo Main to nie main.
Gdy program się nie kompiluje Kompilator wypisze komunikat z numerem linii, na przykład error: expected ';' before 'return' — „oczekiwano średnika przed return”. Najczęstsze przyczyny na początku to brak średnika, niezamknięty cudzysłów i brakująca klamra }. Szukaj błędu w podanej linii i w linii nad nią — brakujący średnik kompilator zauważa często dopiero w następnym wierszu.
Sprawdź się w głowie

Najpierw odpowiedz sam — w myślach albo na kartce — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
cout << "3 * 3";
Pokaż odpowiedź
3 * 3Tekst w cudzysłowie wypisuje się dokładnie tak, jak go napisałeś — komputer niczego nie liczy.
A ten?
cout << 3 * 3 << 3 + 3;
Pokaż odpowiedź
96Komputer liczy oba działania (9 i 6) i wypisuje wyniki jeden za drugim. Bez spacji między nimi wychodzi 96 — dlatego spacje trzeba wypisywać samemu.
Ile wierszy wypisze ten fragment i co będzie w każdym?
cout << "Raz";
cout << "Dwa\n";
cout << "Trzy";
Pokaż odpowiedź
RazDwa TrzyDwa wiersze. Po „Raz” nie ma \n, więc „Dwa” dokleja się w tym samym wierszu. Dopiero \n po „Dwa” przenosi „Trzy” niżej.
Co jest nie tak w tej linijce?
cout << "Czesc!"
Pokaż odpowiedź
brak średnikaNa końcu brakuje ;. Program się nie skompiluje, a kompilator zgłosi błąd w tej albo w następnej linii.

Zmienna, czyli pudełko z nazwą

Wyobraź sobie szafkę z szufladkami. Na każdej szufladce przyklejasz karteczkę z nazwą, a do środka wkładasz jedną rzecz. Gdy potrzebujesz tej rzeczy, nie musisz pamiętać, gdzie leży — wystarczy, że znasz nazwę szufladki. Tak właśnie działa zmienna: to miejsce w pamięci komputera, które ma swoją nazwę i przechowuje jedną wartość.

Bez zmiennych komputer zapominałby wszystko, co przed chwilą policzył. Każdą zmienną opisują trzy rzeczy:

🏷️

typ

Mówi, co wolno włożyć do pudełka: liczbę całkowitą, ułamek, pojedynczy znak czy tekst. Typ podajesz raz — przy tworzeniu zmiennej — i później już się nie zmienia. Na razie poznamy jeden: int, czyli liczby całkowite.

📛

nazwa

Tak wołasz swoje pudełko w kodzie. Wymyślasz ją sam — bez spacji i bez polskich znaków, np. wiek, punkty, liczbaGraczy.

📦

wartość

To, co siedzi w pudełku w tej chwili. Możesz ją wypisać na ekran, użyć w działaniu i w każdej chwili podmienić na inną.

zmienna.cpp
#include <iostream>
using namespace std;

int main() {
    int wiek;          // 1. tworzymy pudełko o nazwie wiek
    wiek = 14;         // 2. wkładamy do niego liczbę 14
    cout << wiek;      // 3. wypisujemy, co jest w środku
    return 0;
}
▶ Wyjście programu
14

Krok po kroku: tworzenie, wkładanie, odczytywanie

int wiek; — to deklaracja. Mówisz komputerowi: „przygotuj pudełko na liczbę całkowitą i nazwij je wiek”. Słowo int to typ, a wiek to nazwa.

wiek = 14; — to przypisanie. Znak = w C++ nie znaczy „równa się”, tylko „włóż”. Czytaj go jako „do wiek wkładam 14”. Wartość z prawej strony trafia do pudełka po lewej.

cout << wiek; — to odczytanie. Uwaga: bez cudzysłowu! cout << "wiek"; wypisałoby słowo „wiek”, a cout << wiek; wypisuje to, co jest w pudełku.

Tworzenie i wkładanie można zrobić w jednej linijce: int wiek = 14;. Tak będziemy pisać najczęściej.

cudzyslow.cpp
int wiek = 14;
cout << "wiek" << "\n";   // słowo wiek
cout << wiek << "\n";     // zawartość pudełka
▶ Wyjście programu
wiek 14
dwie_zmienne.cpp
int a = 5;
int b = 7;
cout << a + b << "\n";
cout << a * b << "\n";
▶ Wyjście programu
12 35

Wartość można zmieniać

Zmienna nazywa się zmienną właśnie dlatego, że jej zawartość może się zmieniać. Gdy wkładasz do pudełka nową wartość, stara znika na zawsze — pudełko mieści tylko jedną rzecz naraz.

zmiana.cpp
int punkty = 10;
cout << punkty << "\n";   // 10
punkty = 25;              // nowa wartość wypiera starą
cout << punkty << "\n";   // 25 — dziesiątki już nie ma
punkty = punkty + 5;      // weź to, co jest, dodaj 5, włóż z powrotem
cout << punkty << "\n";   // 30
▶ Wyjście programu
10 25 30

Przyjrzyj się linijce punkty = punkty + 5;. W matematyce to bzdura — żadna liczba nie jest o 5 większa od samej siebie. Ale w C++ = znaczy „włóż”, więc komputer robi to w dwóch krokach: najpierw liczy prawą stronę (bierze to, co jest teraz w pudełku, czyli 25, i dodaje 5), a potem wkłada wynik, czyli 30, z powrotem do tego samego pudełka.

Śledzenie programu linijka po linijce

Programiści często „wykonują program w głowie”: biorą kartkę i zapisują, co jest w każdym pudełku po każdej linijce. To najlepszy sposób, żeby zrozumieć, co robi kod — i znaleźć błąd, gdy coś nie działa. Spróbujmy:

sledzenie.cpp
int a = 3;
int b = 4;
a = a + b;
b = a * 2;
a = b - 10;
cout << a << " " << b << "\n";
▶ Wyjście programu
4 14
Po linijceab
int a = 3;3—
int b = 4;34
a = a + b;74
b = a * 2;714
a = b - 10;414

Zauważ, że w linijce b = a * 2; używamy nowej wartości a (7), a nie tej z początku (3). Komputer nie pamięta historii — zna tylko to, co jest w pudełku w tej chwili.

Jak nazywać zmienne

Nazwę wymyślasz sam, ale obowiązuje kilka zasad:

NazwaCzy wolno?Dlaczego
wiek✅ takzwykłe małe litery — najprościej
liczbaPunktow✅ takkilka słów sklejonych, każde kolejne z wielkiej litery
liczba_punktow✅ takpodkreślnik też jest dozwolony
x2✅ takcyfry wolno, byle nie na początku
2gracz❌ nienazwa nie może zaczynać się od cyfry
moja zmienna❌ niew nazwie nie może być spacji
łódź❌ niebez polskich liter
int❌ nieto słowo zarezerwowane przez C++

Wielkość liter ma znaczenie: wiek, Wiek i WIEK to trzy różne zmienne. Dobra nazwa mówi, co jest w środku: wiek jest lepsze niż x, a cenaBiletu lepsze niż c. Za tydzień sam podziękujesz sobie za czytelne nazwy.

Puste pudełko nie jest puste Jeśli utworzysz zmienną i nic do niej nie włożysz (int x;), a potem ją wypiszesz, zobaczysz przypadkową liczbę — śmieci, które zostały w tym miejscu pamięci po innym programie. Zawsze nadaj zmiennej wartość, zanim jej użyjesz.
Sprawdź się w głowie

Rozpisz wartości zmiennych w tabelce, tak jak w przykładzie wyżej.

Co wypisze ten fragment?
int x = 5;
x = 8;
cout << x;
Pokaż odpowiedź
8Nowa wartość 8 wyparła starą. Zmienna pamięta tylko ostatnią rzecz, którą do niej włożyłeś.
A ten?
int x = 5;
x = x * 2;
x = x + 1;
cout << x;
Pokaż odpowiedź
115 · 2 = 10, potem 10 + 1 = 11. Każda linijka bierze to, co zostawiła poprzednia.
Uwaga, podchwytliwe: co wypisze ten fragment?
int a = 2;
int b = a;
a = 10;
cout << b;
Pokaż odpowiedź
2W drugiej linijce do b trafiła kopia wartości a, czyli 2. Późniejsza zmiana a nie rusza zawartości b — to dwa osobne pudełka.
Co wypisze ten fragment?
int x = 3;
cout << "x" << x;
Pokaż odpowiedź
x3Najpierw tekst „x” (w cudzysłowie), potem zawartość zmiennej x (bez cudzysłowu). Bez spacji między nimi.
Ćwiczenia · teraz Ty

2 ćwiczenia do tej części

0 / 2 zaliczonych

Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.

Wszystkie ćwiczenia z tej części w sprawdzarce →

cin, czyli dane z zewnątrz

Do tej pory program zawsze robił to samo. Prawdziwe programy dostają jednak dane z zewnątrz: wiek użytkownika, liczby do policzenia, imię. Do wczytywania służy cin (czytaj: „si-in”, od console input) — to klawiatura.

podwojenie.cpp
#include <iostream>
using namespace std;

int main() {
    int n;                   // najpierw pudełko
    cin >> n;                // czekaj, aż ktoś wpisze liczbę, i włóż ją do n
    cout << n * 2 << "\n";   // wypisz podwojoną liczbę
    return 0;
}
▶ Wejście
21
▶ Wyjście
42

Spójrz na strzałki. W cout << n dane płyną ze zmiennej n na ekran. W cin >> n dane płyną z klawiatury do zmiennej n. Strzałki zawsze pokazują kierunek, w którym płyną dane.

Zanim cokolwiek wczytasz, musisz mieć pudełko, do którego to włożysz — dlatego najpierw int n;, a dopiero potem cin >> n;. Wartość nadaje mu dopiero wczytanie.

Zapamiętaj kierunek strzałek cout << x — z x na ekran.   cin >> x — z klawiatury do x.

Kilka liczb naraz

suma.cpp
int a, b;          // dwa pudełka w jednej linijce
cin >> a >> b;     // najpierw do a, potem do b
cout << a + b << "\n";
▶ Wejście
3 8
▶ Wyjście
11

Liczby na wejściu mogą być oddzielone spacją albo stać w osobnych wierszach — dla cin to bez znaczenia. Wejście 3 8 i wejście z liczbą 3 w pierwszym wierszu i 8 w drugim działają identycznie.

cin bierze kolejne liczby z wejścia w takiej kolejności, w jakiej je wypisałeś: pierwsza trafia do a, druga do b. Gdybyś napisał cin >> b >> a;, pierwsza liczba trafiłaby do b.

U Ciebie a w sprawdzarce

Gdy uruchomisz program u siebie, zobaczysz migający kursor — program czeka, aż coś wpiszesz i naciśniesz Enter. Nic się nie dzieje, dopóki nie podasz danych, i to normalne.

W sprawdzarce nikt nie siedzi przy klawiaturze. Sprawdzarka sama „wpisuje” dane testu (to, co w treści zadania nazywa się wejściem), a potem porównuje to, co wypisał program, z oczekiwanym wyjściem. Właśnie dlatego nie wypisujesz „Podaj liczbę:” — sprawdzarka potraktowałaby to jako część odpowiedzi.

Przykład rozwiązany krok po kroku

Przykład Minuty na sekundy
Treść: wczytaj liczbę minut i wypisz, ile to sekund. Wejście: jedna liczba całkowita m (0 ≤ m ≤ 1000). Wyjście: jedna liczba — liczba sekund.
Krok 1 — co jest na wejściu? Jedna liczba całkowita, więc potrzebujesz jednego pudełka typu int i jednego cin.
Krok 2 — co trzeba policzyć? Minuta ma 60 sekund, więc wynik to m · 60.
Krok 3 — co dokładnie wypisać? Samą liczbę. Żadnego „Wynik:”, żadnego „sekund”.
Pokaż rozwiązanie
sekundy.cpp
#include <iostream>
using namespace std;

int main() {
    int m;
    cin >> m;
    cout << m * 60 << "\n";
    return 0;
}
Sprawdź się w głowie

Przy każdym pytaniu podane jest wejście, które „wpisuje” sprawdzarka.

Wejście: 1 2. Co wypisze program?
int a, b;
cin >> a >> b;
cout << b << a;
Pokaż odpowiedź
21Do a trafia 1, do b trafia 2. Wypisujemy najpierw b, potem a — bez spacji.
Wejście: 5 9. Co wypisze program?
int x;
cin >> x;
x = x + 1;
cin >> x;
cout << x;
Pokaż odpowiedź
9Najpierw x = 5, potem 6, ale drugie cin wkłada do x następną liczbę z wejścia, czyli 9. Szóstka przepada.
Co wypisze ten fragment? (Uwaga — to pułapka, która przyda się w ćwiczeniach.)
int a = 1, b = 2;
a = b;
b = a;
cout << a << " " << b;
Pokaż odpowiedź
2 2Po a = b; w a jest 2, a stara jedynka zniknęła na zawsze. b = a; wkłada do b tę dwójkę. Tak nie da się zamienić dwóch zmiennych miejscami!
Czy ta linijka ma sens?
cin >> 5;
Pokaż odpowiedź
nie — błąd kompilacjicin wkłada wczytaną wartość do pudełka, a 5 to nie pudełko, tylko liczba. Po prawej stronie >> zawsze stoi nazwa zmiennej.

int — liczby całkowite i działania

Do tej pory pisaliśmy int bez większego wyjaśnienia. Czas na konkrety. int (od angielskiego integer — liczba całkowita) przechowuje liczby bez przecinka: 0, 7, −15, 2026. Mieści liczby mniej więcej od −2 miliardów do +2 miliardów — to wystarcza na zdecydowaną większość zadań. Co zrobić, gdy to za mało, dowiesz się w części 10.

Pięć działań

DziałanieZapisPrzykładWynik
dodawaniea + b7 + 29
odejmowaniea - b7 - 25
mnożeniea * b7 * 214
dzielenie całkowitea / b7 / 23
reszta z dzieleniaa % b7 % 21

Dzielenie na int-ach obcina ułamek

To najważniejsza pułapka tej części. Gdy dzielisz dwie liczby całkowite, wynik też jest liczbą całkowitą — część po przecinku po prostu znika. Nie ma żadnego zaokrąglania: 7 / 2 to 3 (a nie 3,5 ani 4), a 99 / 10 to 9.

dzielenie.cpp
cout << 7 / 2 << "\n";     // 3
cout << 99 / 10 << "\n";   // 9
cout << 2 / 5 << "\n";     // 0 — dwójka nie mieści w sobie ani jednej piątki
cout << -7 / 2 << "\n";    // -3 — ucina w stronę zera
▶ Wyjście programu
3 9 0 -3

Brzmi jak wada, ale bardzo często to dokładnie to, czego potrzebujesz. Ile pełnych godzin to 150 minut? 150 / 60 to 2. Ile pełnych paczek po 6 jajek zrobisz z 20 jajek? 20 / 6 to 3. Dzielenie całkowite odpowiada na pytanie „ile pełnych razy”.

Reszta z dzielenia: %

Operator % (czytaj: „modulo”) daje to, co zostaje po dzieleniu całkowitym. 17 / 5 to 3, bo 3 · 5 = 15 — i zostają 2. Więc 17 % 5 to 2. Pomyśl o rozdawaniu: 17 cukierków dla 5 osób — każdy dostaje 3 (to jest 17 / 5), a 2 zostają w torbie (to jest 17 % 5).

ZapisWynikDlaczego
17 % 5217 = 3 · 5 + 2
20 % 5020 dzieli się przez 5 bez reszty
3 % 533 = 0 · 5 + 3
2026 % 106reszta z dzielenia przez 10 to ostatnia cyfra
n % 20 lub 10 dla liczb parzystych, 1 dla nieparzystych

Dwa triki z / i %, których będziesz używać bardzo często: dzielenie przez 10 obcina ostatnią cyfrę, a reszta z dzielenia przez 10 to właśnie ta ostatnia cyfra. Podobnie z minutami i sekundami — / 60 mówi, ile pełnych minut, a % 60, ile sekund zostało.

triki.cpp
int n = 2026;
cout << n % 10 << "\n";        // 6   — ostatnia cyfra
cout << n / 10 << "\n";        // 202 — liczba bez ostatniej cyfry
cout << n / 10 % 10 << "\n";   // 2   — przedostatnia cyfra

int s = 135;
cout << s / 60 << " min " << s % 60 << " s\n";   // 2 min 15 s
▶ Wyjście programu
6 202 2 2 min 15 s

Kolejność działań i nawiasy

C++ liczy w tej samej kolejności co matematyka: najpierw *, / i %, potem + i -. Działania tej samej rangi wykonuje od lewej do prawej. Nawiasy zmieniają kolejność — a gdy masz wątpliwości, po prostu dodaj nawias, nic nie tracisz.

kolejnosc.cpp
cout << 2 + 3 * 4 << "\n";     // 14 — najpierw 3 * 4
cout << (2 + 3) * 4 << "\n";   // 20 — nawias najpierw
cout << 20 / 2 * 5 << "\n";    // 50 — od lewej: (20 / 2) * 5
cout << 20 / (2 * 5) << "\n";  // 2
▶ Wyjście programu
14 20 50 2

Skróty: +=, -=, ++

Zapis x = x + 5; jest tak częsty, że ma skrót. Oba zapisy w każdym wierszu tabeli robią dokładnie to samo:

SkrótPełny zapisZnaczy
x += 5;x = x + 5;zwiększ o 5
x -= 2;x = x - 2;zmniejsz o 2
x *= 3;x = x * 3;pomnóż przez 3
x /= 2;x = x / 2;podziel przez 2
x++;x = x + 1;zwiększ o 1
x--;x = x - 1;zmniejsz o 1

Sztuczka: dzielenie w górę

Czasem wynik dzielenia trzeba zaokrąglić w górę. Na wycieczkę jedzie 53 uczniów, a bus ma 20 miejsc. Ile busów zamówić? 53 / 20 to 2 — ale dwa busy pomieszczą tylko 40 osób! Potrzebujemy 3. Dla liczb dodatnich działa wzór: a / b zaokrąglone w górę to (a + b − 1) / b.

w_gore.cpp
int uczniowie = 53, miejsca = 20;
cout << uczniowie / miejsca << "\n";                  // 2 — za mało busów!
cout << (uczniowie + miejsca - 1) / miejsca << "\n";  // 3
cout << (40 + miejsca - 1) / miejsca << "\n";         // 2 — dla 40 osób wystarczą dwa
▶ Wyjście programu
2 3 2

Dlaczego to działa? Jeśli a dzieli się przez b bez reszty (jak 40 przez 20), dodane b − 1 to za mało, żeby wynik urósł. Jeśli zostaje choć 1 osoba, dodane b − 1 „dopełnia” resztę do pełnego busa i wynik rośnie o 1. Ta sztuczka przyda się w bazie zadań.

Sprawdź się w głowie

Policz na kartce, dopiero potem sprawdź.

Co wypisze ten fragment?
cout << 17 / 5 << " " << 17 % 5;
Pokaż odpowiedź
3 217 = 3 · 5 + 2. Dzielenie całkowite daje 3, reszta to 2.
A ten?
cout << 10 - 2 * 3;
Pokaż odpowiedź
4Najpierw mnożenie: 2 · 3 = 6, potem 10 − 6 = 4.
Co będzie w x na końcu?
int x = 10;
x += 5;
x *= 2;
x--;
cout << x;
Pokaż odpowiedź
2910 + 5 = 15, potem 15 · 2 = 30, a x-- zmniejsza o 1: 29.
Co wypisze ten fragment?
cout << 9 / 10 << " " << 9 % 10;
Pokaż odpowiedź
0 9Dziewiątka nie mieści w sobie ani jednej dziesiątki (9 / 10 = 0), więc cała zostaje jako reszta (9 % 10 = 9).

double — liczby z przecinkiem

Średnia ocen, temperatura, cena z groszami — wiele wartości nie jest liczbami całkowitymi. Do nich służy typ double. Uwaga na zapis: w C++ zamiast przecinka piszemy kropkę: 3.14, 0.5, -2.75.

double.cpp
double temperatura = 36.6;
double cena = 4.99;
cout << temperatura << "\n";
cout << cena * 3 << "\n";     // trzy rzeczy po 4.99 zł
cout << 10.0 / 4 << "\n";
▶ Wyjście programu
36.6 14.97 2.5
Kropka, nie przecinek double x = 3,14; to błąd albo — co gorsze — coś zupełnie innego, niż myślisz. Liczby z ułamkiem zawsze piszemy z kropką. Także na wejściu: sprawdzarka poda 2.5, a nie 2,5.

double a float

Istnieje też typ float — również na liczby z przecinkiem, ale mniej dokładny: pamięta tylko 6–7 pierwszych cyfr liczby. double pamięta ich 15–16. Na co dzień zawsze wybieraj double. float spotkasz czasem w starszych materiałach — przy liczbach dopisuje się wtedy literkę f, np. 4.75f.

Wielka pułapka: 7 / 2

Pamiętasz, że 7 / 2 to w C++ 3? Dzieje się tak, bo obie liczby są całkowite. Wystarczy jednak, że choć jedna z nich jest typu double, a całe dzielenie odbędzie się na liczbach z przecinkiem:

ZapisTypyWynik
7 / 2int / int3
7.0 / 2double / int3.5
7 / 2.0int / double3.5
7.0 / 2.0double / double3.5

Najbardziej podstępna wersja tej pułapki wygląda tak:

pulapka.cpp
double wynik = 7 / 2;
cout << wynik << "\n";      // 3, a nie 3.5!

double dobrze = 7 / 2.0;
cout << dobrze << "\n";     // 3.5
▶ Wyjście programu
3 3.5

Choć wynik trafia do zmiennej double, samo dzielenie liczy się wcześniej — na dwóch int-ach. Komputer liczy 7 / 2 = 3 i dopiero tę trójkę wkłada do pudełka double. Typ zmiennej po lewej stronie nie ma wpływu na to, jak liczona jest prawa strona.

Zapamiętaj Chcesz wyniku z przecinkiem? Zadbaj, żeby w dzieleniu była choć jedna liczba double: 7 / 2.0, a / 2.0 albo zmienna typu double.

Ile cyfr po kropce? fixed i setprecision

Zwykłe cout wypisuje liczbę double „jak mu wygodnie”: pomija zera na końcu i pokazuje najwyżej 6 cyfr. W zadaniach prawie zawsze jest napisane, ile cyfr po kropce masz wypisać — wtedy używasz dwóch poleceń z biblioteki <iomanip>:

precyzja.cpp
#include <iostream>
#include <iomanip>     // tu mieszkają fixed i setprecision
using namespace std;

int main() {
    double x = 10.0 / 3;
    cout << x << "\n";                              // 3.33333
    cout << fixed << setprecision(2) << x << "\n";  // 3.33
    cout << 2.5 << "\n";                            // 2.50 — ustawienie zostaje
    cout << 7.0 << "\n";                            // 7.00
    cout << 1.006 << "\n";                          // 1.01 — zaokrągla!
    return 0;
}
▶ Wyjście programu
3.33333 3.33 2.50 7.00 1.01

fixed mówi „zawsze wypisuj cyfry po kropce”, a setprecision(2) — „dokładnie dwie”. Liczba jest przy tym zaokrąglana tak jak w szkole: 1.006 to 1.01, a 3.333 to 3.33. Wystarczy ustawić to raz, na przykład na początku programu — działa dla wszystkich kolejnych liczb.

Wczytywanie liczb z przecinkiem

srednia.cpp
double a, b;
cin >> a >> b;
cout << fixed << setprecision(2);
cout << (a + b) / 2 << "\n";
▶ Wejście
2.5 4
▶ Wyjście
3.25

Do zmiennej double możesz wczytać zarówno 2.5, jak i 4 — liczba całkowita to też liczba rzeczywista.

Nawias w (a + b) / 2 jest konieczny. Bez niego komputer najpierw podzieliłby b przez 2 (mnożenie i dzielenie są przed dodawaniem), a dopiero potem dodał a.

Komputer liczy w przybliżeniu double przechowuje większość ułamków w przybliżeniu — tak jak 1/3 to w zapisie dziesiętnym 0,3333… bez końca. Dlatego 0.1 + 0.2 to w komputerze 0.30000000000000004. Na co dzień tego nie zauważysz, bo setprecision ładnie zaokrągla. Ale nigdy nie porównuj liczb double operatorem == — wrócimy do tego w części o bool.
Sprawdź się w głowie

Uważaj na typy liczb w każdym dzieleniu.

Co wypisze ten fragment?
cout << 5 / 2 << " " << 5 / 2.0;
Pokaż odpowiedź
2 2.5Pierwsze dzielenie jest na dwóch int-ach (obcina ułamek), drugie ma liczbę 2.0, więc liczy na double.
A ten?
double x = 9 / 4;
cout << x;
Pokaż odpowiedź
29 / 4 liczy się na int-ach, zanim wynik trafi do x. 2.25 zamienia się w 2 i dopiero dwójka ląduje w pudełku double.
Co wypisze ten fragment?
cout << fixed << setprecision(2) << 7 / 3.0;
Pokaż odpowiedź
2.337 / 3.0 to 2.3333…, a setprecision(2) zostawia dwie cyfry po kropce.
Ile wyniesie w?
int a = 7, b = 2;
double w = a / b;
cout << w;
Pokaż odpowiedź
3a i b to int-y, więc a / b to 3 — i to 3 trafia do w. Typ zmiennej w nie ma tu nic do rzeczy. Jak to naprawić? Zobaczysz w części 11 (rzutowanie).

char — pojedynczy znak

char (od character — znak) przechowuje dokładnie jeden znak: literę, cyfrę, kropkę, wykrzyknik albo spację. Znak zapisujesz w apostrofach, czyli pojedynczych cudzysłowach: 'a', 'Z', '7', '!'.

znaki.cpp
char litera = 'K';
char cyfra = '7';
char znak = '?';
cout << litera << cyfra << znak << "\n";
▶ Wyjście programu
K7?

'a', "a" i a — trzy różne rzeczy

ZapisCo to jestUwagi
'a'znak (char)dokładnie jeden znak, w apostrofach
"a"napis (string)tekst w cudzysłowie — o napisach w następnej części
anazwa zmiennejbez cudzysłowów — komputer szuka pudełka o nazwie a

Pomylenie apostrofu z cudzysłowem to jeden z najczęstszych błędów kompilacji na początku. Zapis 'ab' też jest błędem: w apostrofach mieści się tylko jeden znak.

Każdy znak to liczba

Komputer nie zna liter — zna tylko liczby. Dlatego każdy znak ma swój numer w tabeli, która nazywa się ASCII. Litera A ma numer 65, B — 66, C — 67 i tak dalej. Nie musisz pamiętać numerów, ale zapamiętaj trzy fakty: małe litery od a do z leżą w tabeli jedna za drugą, wielkie litery od A do Z też, i cyfry od 0 do 9 też.

ZnakiKody ASCII
' ' (spacja)32
'0' … '9'48 … 57
'A' … 'Z'65 … 90
'a' … 'z'97 … 122

Numer znaku zobaczysz, zamieniając go na int — wpisujesz typ w nawiasie przed wartością: (int)c. W drugą stronę działa (char) — z numeru robi znak. Takie wymuszone zamiany typu nazywają się rzutowaniem; więcej o nich w części 11.

ascii.cpp
char c = 'A';
cout << (int)c << "\n";      // 65
cout << (char)66 << "\n";    // B
cout << (int)'7' << "\n";    // 55 — znak 7 to NIE liczba 7
▶ Wyjście programu
65 B 55

Liczenie na znakach

Skoro znaki to liczby, można na nich liczyć. Trzeba tylko uważać, co wychodzi: znak plus liczba to liczba (int), a nie znak.

liczenie_na_znakach.cpp
char c = 'a';
cout << c + 1 << "\n";           // 98 — liczba!
cout << (char)(c + 1) << "\n";   // b  — zamieniona z powrotem na znak
c++;                             // zwiększamy samą zmienną char
cout << c << "\n";               // b
▶ Wyjście programu
98 b b

Najczęściej używana sztuczka ze znakami to odejmowanie. Różnica dwóch znaków to odległość między nimi w tabeli ASCII:

odleglosci.cpp
char litera = 'd';
cout << litera - 'a' << "\n";              // 3 — d jest 3 miejsca za a
cout << litera - 'a' + 1 << "\n";          // 4 — d to czwarta litera alfabetu

char cyfra = '7';
cout << cyfra - '0' << "\n";               // 7 — wartość cyfry
cout << (cyfra - '0') * 2 << "\n";         // 14 — teraz można liczyć

char mala = 'k';
cout << (char)(mala - 'a' + 'A') << "\n";  // K — ta sama litera, ale wielka
▶ Wyjście programu
3 4 7 14 K

Rozbierzmy ostatnią linijkę na kawałki. mala - 'a' mówi, którą literą od początku alfabetu jest k — licząc od zera, wychodzi 10. Dodanie 'A' przesuwa nas o tyle samo miejsc, ale od wielkiego A: wychodzi numer litery K. Na koniec (char) zamienia ten numer na znak.

Wczytywanie znaku działa jak zwykle: cin >> c; wczytuje jeden znak, pomijając spacje i entery. Przy wejściu x y dwa kolejne cin >> c dadzą x i y.

Sprawdź się w głowie

Pamiętaj: znak + liczba = liczba.

Co wypisze ten fragment?
cout << (char)('a' + 2);
Pokaż odpowiedź
cDwa miejsca za a jest c, a (char) zamienia numer z powrotem na znak.
A ten?
cout << 'A' + 1;
Pokaż odpowiedź
66Znak plus liczba to liczba: 65 + 1 = 66. Bez (char) cout wypisuje numer, a nie literę B.
Co wypisze ten fragment?
char c = '5';
cout << c - '0' + 1;
Pokaż odpowiedź
6'5' − '0' to 5 (53 − 48), plus 1 daje 6.
Która to litera alfabetu?
char c = 'z';
cout << c - 'a' + 1;
Pokaż odpowiedź
26z jest 25 miejsc za a, a numerujemy od 1 — więc 26.

string — tekst

char mieści jeden znak, a co z imieniem albo całym zdaniem? Do tego służy string — napis dowolnej długości. Napisy zapisujesz w cudzysłowie: "Kacper", "Ala ma kota". Żeby używać typu string, dopisz na górze programu #include <string>.

powitanie.cpp
#include <iostream>
#include <string>
using namespace std;

int main() {
    string imie = "Ola";
    cout << "Czesc, " << imie << "!\n";
    return 0;
}
▶ Wyjście programu
Czesc, Ola!

Wczytywanie słowa

imie_nazwisko.cpp
string imie, nazwisko;
cin >> imie >> nazwisko;
cout << nazwisko << " " << imie << "\n";
▶ Wejście
Jan Kowalski
▶ Wyjście
Kowalski Jan

cin >> s; wczytuje jedno słowo — wszystko do pierwszej spacji albo do końca wiersza. Przy wejściu Jan Kowalski pierwsze cin wczyta tylko Jan, a drugie — Kowalski.

Jak wczytać cały wiersz razem ze spacjami, dowiesz się w następnej lekcji, Input / Output.

Sklejanie napisów

Napisy skleja się plusem. Sklejanie nie dodaje spacji — jeśli jej chcesz, musisz ją dokleić sam, jako osobny kawałek napisu.

sklejanie.cpp
string a = "kot";
string b = "let";
string c = a + b;           // "kotlet"
string d = a + " i " + b;   // "kot i let"
c += "y";                   // dopisz na końcu: "kotlety"
cout << c << "\n" << d << "\n";
▶ Wyjście programu
kotlety kot i let

Długość napisu

dlugosc.cpp
string s = "olimpiada";
cout << s.length() << "\n";   // 9
cout << s.size() << "\n";     // 9 — to samo co length()
▶ Wyjście programu
9 9

Kropka po nazwie zmiennej oznacza: „zapytaj ten napis o coś”. s.length() pyta napis s o jego długość, czyli liczbę znaków. Nawiasy na końcu są obowiązkowe.

Spacja i znaki przestankowe też są znakami: "Ala ma kota" ma długość 11.

Pojedyncze litery: s[0]

Do konkretnej litery napisu dostajesz się przez jej numer w nawiasie kwadratowym. Uwaga: numeracja zaczyna się od zera! Pierwsza litera to s[0], druga s[1], a ostatnia — s[s.length() - 1].

s = "bajtek"bajtek
numer012345
zapiss[0]s[1]s[2]s[3]s[4]s[5]
litery.cpp
string s = "bajtek";
cout << s[0] << "\n";                // b
cout << s[2] << "\n";                // j
cout << s[s.length() - 1] << "\n";   // k — ostatnia litera (s.length() to 6, a numery idą do 5)
▶ Wyjście programu
b j k

Każda litera napisu to wartość typu char — możesz z nią robić wszystko, co z char z poprzedniej części: porównywać, zamieniać na wielką, liczyć jej numer w alfabecie.

Napis z powtórzonym znakiem

Przydatny skrót: string(n, znak) tworzy napis z n powtórzeń jednego znaku. Przyda się do rysowania linii i ramek.

powtorzenia.cpp
cout << string(5, '*') << "\n";
string linia = string(12, '-');
cout << linia << "\n";
▶ Wyjście programu
***** ------------
Napis + liczba = kłopot "Wiek: " + 14 nie dokleja liczby do napisu — kompilator pozwoli to napisać, ale wynik będzie zupełnie bez sensu. Liczby wypisuj osobnym <<: cout << "Wiek: " << 14;. A jeśli naprawdę potrzebujesz zrobić z liczby napis, użyj to_string(14) — pokażemy to w części 11.
Sprawdź się w głowie

Pamiętaj: litery numerujemy od zera.

Co wypisze ten fragment?
string s = "abc";
cout << s + s;
Pokaż odpowiedź
abcabcPlus skleja napisy — bez żadnej spacji.
A ten?
string s = "kajak";
cout << s.length() << s[1];
Pokaż odpowiedź
5aNapis ma 5 liter, a s[1] to druga litera (numer 1), czyli a.
Liczby czy napisy?
string a = "1", b = "2";
cout << a + b;
Pokaż odpowiedź
12To napisy, a nie liczby — plus je skleja. Gdyby a i b były int-ami, wyszłoby 3.
Co wypisze ten fragment?
string s = "C++";
cout << s[s.length() - 1] << s[0];
Pokaż odpowiedź
+COstatni znak napisu „C++” to plus, a pierwszy to C.

bool, czyli prawda albo fałsz

Ostatni z podstawowych typów jest najprostszy: bool mieści tylko dwie wartości — true (prawda) i false (fałsz). Służy do zapamiętania odpowiedzi na pytanie „tak czy nie?”. Czy gracz wygrał? Czy liczba jest parzysta? Czy uczeń jest pełnoletni?

Najważniejsze: wartość typu bool powstaje sama, gdy coś porównujesz. Zapis wiek >= 18 to nie pytanie bez odpowiedzi — to gotowe true albo false, które możesz od razu włożyć do zmiennej albo wypisać.

bool.cpp
bool zdany = true;
int wiek = 17;
bool pelnoletni = (wiek >= 18);   // porównanie daje false

cout << zdany << "\n";
cout << pelnoletni << "\n";
▶ Wyjście programu
1 0
boolalpha.cpp
// C++ wypisuje bool jako liczbę:
// true to 1, a false to 0
cout << true << " " << false << "\n";

// boolalpha każe pisać słowami
cout << boolalpha;
cout << true << " " << false << "\n";
▶ Wyjście programu
1 0 true false

Pod spodem bool jest po prostu liczbą: true to 1, a false to 0. Dlatego cout domyślnie wypisuje cyfry. Jeśli zadanie każe wypisać słowa true/false, wystarczy raz wypisać boolalpha.

Porównania

ZapisCzyta sięDaje true, gdy…Przykład
a == ba równe bobie wartości są takie same3 == 3 → true
a != ba różne od bwartości się różnią3 != 5 → true
a < ba mniejsze od ba jest mniejsze2 < 5 → true
a > ba większe od ba jest większe2 > 5 → false
a <= ba mniejsze lub równe ba nie jest większe5 <= 5 → true
a >= ba większe lub równe ba nie jest mniejsze4 >= 5 → false
= to nie to samo co == Pojedyncze = wkłada wartość do zmiennej, a podwójne == sprawdza, czy dwie rzeczy są równe. W porównaniach zawsze piszemy ==. To pułapka, na której potyka się prawie każdy na początku.

Nawias w cout jest obowiązkowy

Wynik porównania wypisuj zawsze w nawiasie: cout << (a < b);. Bez nawiasu, czyli cout << a < b;, komputer najpierw wykona cout << a, a potem spróbuje porównać cout z b — i program się nie skompiluje.

Łączenie warunków: &&, || i !

Porównania można łączyć, tak jak w zwykłym języku łączysz zdania słowami „i”, „lub” i „nie”:

ZapisCzyta sięDaje true, gdy…Przykład
x && yx oraz yoba są truen >= 10 && n <= 99 — liczba dwucyfrowa
x || yx lub yprzynajmniej jeden jest trued == 6 || d == 7 — weekend
!xnie xx jest false — odwraca odpowiedź!(n > 100) — n nie jest większe od 100
xyx && yx || y
truetruetruetrue
truefalsefalsetrue
falsetruefalsetrue
falsefalsefalsefalse
laczenie.cpp
int n = 42;
cout << (n >= 10 && n <= 99) << "\n";   // 1 — dwucyfrowa
cout << (n % 2 == 0 || n < 0) << "\n";  // 1 — wystarczy, że parzysta
cout << !(n > 100) << "\n";             // 1 — NIE jest większa od 100
▶ Wyjście programu
1 1 1

Gdy w jednym warunku łączysz && i ||, dodawaj nawiasy, żeby było jasne, co łączy się z czym: (a && b) || c to co innego niż a && (b || c).

Pułapka: a ≤ x ≤ b W matematyce piszesz 1 ≤ x ≤ 10. W C++ zapis 1 <= x <= 10 się skompiluje, ale działa zupełnie inaczej: komputer najpierw liczy 1 <= x (wychodzi 0 albo 1), a potem sprawdza, czy to 0 lub 1 jest mniejsze lub równe 10 — co jest zawsze prawdą. Zawsze rozbijaj taki warunek na dwa porównania: 1 <= x && x <= 10.

bool to też liczba

W działaniach arytmetycznych true zachowuje się jak 1, a false jak 0. To pozwala robić sprytne rzeczy jeszcze bez instrukcji if:

bool_jako_liczba.cpp
int a = 5, b = -3, c = 8;
int dodatnich = (a > 0) + (b > 0) + (c > 0);   // 1 + 0 + 1
cout << dodatnich << "\n";                     // 2

int x = 7;
cout << 100 * (x > 5) << "\n";   // 100 — mnożenie przez 1 „włącza” liczbę
cout << 100 * (x > 9) << "\n";   // 0   — mnożenie przez 0 ją „wyłącza”
▶ Wyjście programu
2 100 0

Porównywanie napisów i liczb z przecinkiem

Zmienne typu string porównujesz tymi samymi operatorami. == sprawdza, czy napisy są identyczne, a < — czy pierwszy jest wcześniej w słowniku: komputer porównuje litery od lewej, aż trafi na pierwszą różnicę. Dlatego "ala" < "ola" to true (a jest przed o), a "kot" < "koc" to false (t jest za c).

Liczb double nie porównuj operatorem ==. Pamiętasz, że 0.1 + 0.2 to w komputerze 0.30000000000000004? Dlatego 0.1 + 0.2 == 0.3 daje false!

Po co to wszystko? bool jest paliwem dla instrukcji if, którą poznasz w lekcji If / Else — to ona pozwala programowi podjąć decyzję i zrobić jedno albo drugie. Ale już teraz, wypisując 1 albo 0, rozwiążesz sporo zadań.

Sprawdź się w głowie

true to 1, false to 0.

Co wypisze ten fragment?
cout << (5 > 3) << (2 == 3);
Pokaż odpowiedź
105 > 3 to true (1), 2 == 3 to false (0). Wypisane jedno za drugim dają 10.
A ten?
cout << boolalpha << (7 % 2 == 1);
Pokaż odpowiedź
true7 % 2 to 1, więc porównanie jest prawdziwe, a boolalpha każe wypisać słowo.
Co wypisze ten fragment?
int x = 15;
cout << (x > 10 && x < 20);
cout << (x < 10 || x > 20);
Pokaż odpowiedź
1015 leży między 10 a 20, więc pierwsze to 1. Nie jest ani mniejsze od 10, ani większe od 20, więc drugie to 0.
Ile wyjdzie?
cout << (3 > 2) + (2 > 1) + (1 > 0);
Pokaż odpowiedź
3Wszystkie trzy porównania są prawdziwe: 1 + 1 + 1 = 3.

Stałe wartości i typ odgadywany przez komputer

const zamyka pudełko na klucz: wartość ustawiasz raz, przy tworzeniu zmiennej, i od tej pory nikt — nawet Ty przez pomyłkę — jej nie podmieni. Próba zmiany kończy się błędem kompilacji.

const.cpp
const double PI = 3.14159265358979;
const int CENA_BILETU = 28;

double r = 2;
cout << PI * r * r << "\n";          // pole koła o promieniu 2
cout << 3 * CENA_BILETU << "\n";     // trzy bilety
// PI = 3;    ← błąd kompilacji: PI jest stałą
▶ Wyjście programu
12.5664 84

Po co zamykać pudełko na klucz? Po pierwsze, to ochrona przed pomyłką: jeśli przez nieuwagę spróbujesz zmienić stałą, kompilator od razu zaprotestuje. Po drugie, to jedno miejsce do zmiany: gdy cena biletu wzrośnie, poprawiasz jedną linijkę, a nie dziesięć liczb rozsianych po programie. Po trzecie, to czytelność: 3 * CENA_BILETU mówi więcej niż 3 * 28.

Stałe zwyczajowo nazywa się WIELKIMI literami, ze słowami oddzielonymi podkreślnikiem — od razu widać, że to stała, a nie zwykła zmienna.

auto — niech komputer odgadnie typ

auto działa odwrotnie niż wszystko dotąd: nie podajesz typu, tylko każesz komputerowi samemu go rozpoznać po tym, co stoi po prawej stronie znaku =.

auto.cpp
auto liczba = 10;     // int
auto ulamek = 2.5;    // double
auto znak = 'x';      // char
auto wynik = 7 / 2;   // int — i wartość 3!
cout << liczba << " " << ulamek << " " << znak << " " << wynik << "\n";
▶ Wyjście programu
10 2.5 x 3

auto nie zgaduje, „co miałeś na myśli” — patrzy tylko na prawą stronę. 7 / 2 to int, więc wynik też będzie int, z wartością 3. Na początku nauki pisz typy wprost — tak łatwiej zrozumieć, co się dzieje. auto przyda się później, przy długich nazwach typów.

Sprawdź się w głowie

Trzy krótkie pytania o stałe i auto.

Co wypisze ten fragment?
const int X = 5;
cout << X * 2;
Pokaż odpowiedź
10Stałą można czytać i używać w działaniach — nie wolno jej tylko zmieniać.
A co się stanie tutaj?
const int X = 5;
X = 6;
Pokaż odpowiedź
błąd kompilacjiDo stałej nie można niczego przypisać. Kompilator odrzuci program, zanim w ogóle go uruchomisz.
Co wypisze ten fragment?
auto a = 5;
auto b = 2.0;
cout << a / 2 << " " << a / b;
Pokaż odpowiedź
2 2.5a jest int-em (5), b jest double (2.0). Pierwsze dzielenie jest na int-ach, drugie — na double.
Ćwiczenia · teraz Ty

2 ćwiczenia do tej części

0 / 2 zaliczonych

Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.

Wszystkie ćwiczenia z tej części w sprawdzarce →

Ile mieści każdy typ — i co, gdy to za mało

Każde pudełko ma ograniczoną wielkość. Zmienna typu int zajmuje w pamięci 4 bajty, czyli 32 zera i jedynki — tyle wystarcza na liczby od −2 147 483 648 do 2 147 483 647, czyli mniej więcej od minus do plus dwóch miliardów.

Co się stanie, gdy wynik nie zmieści się w pudełku? Pomyśl o liczniku kilometrów w starym samochodzie, który ma 6 cyfr: po 999 999 pokazuje znowu 000 000. W C++ dzieje się coś podobnego — liczba „przekręca się” na drugi koniec zakresu. Nazywa się to przepełnieniem (ang. overflow). Program nie zgłasza żadnego błędu, tylko po cichu wypisuje bzdurę:

przepelnienie.cpp
int a = 100000, b = 100000;
cout << a * b << "\n";      // 1410065408 zamiast 10000000000!

int x = 2147483647;         // największy int
x = x + 1;
cout << x << "\n";          // -2147483648 — przekręcił się na sam dół
▶ Wyjście programu
1410065408 -2147483648

Najgorsze w przepełnieniu jest to, że wynik wygląda jak zwykła liczba. Program się nie wysypuje i nie ostrzega — dlatego trzeba o nim myśleć, zanim zaczniesz pisać kod.

long long — większe pudełko

Gdy liczby mogą przekroczyć dwa miliardy, użyj typu long long (dwa razy słowo long). Zajmuje 8 bajtów i mieści liczby do około 9,2 · 10¹⁸ — to dziewiętnaście cyfr. Tak dużo, że w zadaniach z tej lekcji zawsze wystarczy.

long_long.cpp
long long a = 100000, b = 100000;
cout << a * b << "\n";        // 10000000000 — teraz dobrze

long long duza = 9000000000000000000;   // 9 · 10^18 — mieści się
cout << duza + 1 << "\n";
▶ Wyjście programu
10000000000 9000000000000000001

Pułapka: liczy się typ działania, nie wyniku

Ten przykład zaskakuje prawie wszystkich:

za_pozno.cpp
int a = 100000, b = 100000;
long long w = a * b;              // ŹLE: a * b liczy się na int-ach
long long v = 1LL * a * b;        // DOBRZE: 1LL to jedynka typu long long
long long u = (long long)a * b;   // DOBRZE: zamiana jednej z liczb
cout << w << "\n" << v << "\n" << u << "\n";
▶ Wyjście programu
1410065408 10000000000 10000000000

To ta sama historia co z double wynik = 7 / 2; w części 05. Komputer najpierw liczy prawą stronę na typach, które w niej występują — dwa int-y, więc wynik jest int i się przepełnia — a dopiero potem wkłada ten zepsuty wynik do pudełka long long. Wtedy jest już za późno. Najprościej: jeśli wiesz, że liczby będą duże, od razu wczytuj je do zmiennych long long.

Jak sprawdzić, czy wynik się zmieści?

Zanim napiszesz program, spójrz na ograniczenia w treści zadania i wstaw do wzoru największe możliwe liczby. Przykład: a, b ≤ 10⁹, a liczysz a · b. Największy wynik to 10⁹ · 10⁹ = 10¹⁸ — więcej niż 2 · 10⁹, czyli int nie wystarczy, ale mniej niż 9 · 10¹⁸, więc long long wystarczy.

Zapamiętaj dwie liczby int kończy się w okolicach 2 · 10⁹ (dwóch miliardów), a long long w okolicach 9 · 10¹⁸. Jeśli wynik może przekroczyć dwa miliardy — bierz long long. Nic na tym nie tracisz.

Wszystkie typy w jednej tabeli

Całej tabeli nie musisz znać na pamięć — na start wystarczą wiersze z int, long long i double.

TypRozmiarZakresKiedy używać
bool1 bajtfalse / trueodpowiedź „tak/nie”
char1 bajt-128 … 127jeden znak: litera, cyfra, przecinek
short2 bajty-32 768 … 32 767prawie nigdy — int jest wygodniejszy
int4 bajty-2 147 483 648 … 2 147 483 647Twój domyślny typ na liczby całkowite
unsigned int4 bajty0 … 4 294 967 295tylko liczby nieujemne — na start omijaj
long long8 bajtów-9,22·10¹⁸ … 9,22·10¹⁸gdy liczba przekracza 2 miliardy
unsigned long long8 bajtów0 … 1,84·10¹⁹bardzo duże liczby nieujemne — rzadko
float4 bajty~7 cyfr znaczącychmało dokładny — lepiej weź double
double8 bajtów~15–16 cyfr znaczącychTwój domyślny typ na liczby z przecinkiem
long double16 bajtów~18–19 cyfr znaczącychgdy double nie wystarcza — rzadkość
stringzmiennydowolna długość tekstuimię, słowo albo całe zdanie

Granice w programie: INT_MAX i sizeof

granice.cpp
#include <iostream>
#include <climits>     // INT_MAX, INT_MIN, LLONG_MAX
using namespace std;

int main() {
    cout << INT_MAX << "\n";
    cout << INT_MIN << "\n";
    cout << LLONG_MAX << "\n";
    cout << sizeof(int) << " " << sizeof(long long) << "\n";
    return 0;
}
▶ Wyjście programu
2147483647 -2147483648 9223372036854775807 4 8

Granic nie musisz pamiętać co do cyfry — są gotowe w nagłówku <climits> jako INT_MAX, INT_MIN i LLONG_MAX. Przydają się, gdy trzeba sprawdzić, czy liczba mieści się w int.

sizeof(typ) mówi, ile bajtów zajmuje dany typ.

unsigned — na razie omijaj Typy z unsigned nie mają liczb ujemnych, więc odejmowanie potrafi zaskoczyć: dla unsigned int u = 3; wynik u - 5 to nie −2, tylko 4 294 967 294 — liczba przeskakuje na drugi koniec zakresu. Na początku trzymaj się zwykłego int i long long.
Sprawdź się w głowie

Int czy long long? Wstaw największe możliwe liczby.

Czy liczba 3 000 000 000 zmieści się w int?
int x = 3000000000;
Pokaż odpowiedź
nieint kończy się na 2 147 483 647, a 3 miliardy to więcej. Trzeba long long.
W zadaniu a, b ≤ 100 000. Liczysz a · b. Jaki typ?
??? w = a * b;
Pokaż odpowiedź
long longNajwiększy wynik to 10⁵ · 10⁵ = 10¹⁰ — więcej niż 2 · 10⁹. Uwaga: a i b też trzeba wczytać do long long (albo napisać 1LL * a * b).
Co jest nie tak w tym kodzie?
int a = 50000;
long long x = a * a;
Pokaż odpowiedź
przepełnieniea * a liczy się na int-ach: 2,5 · 10⁹ nie mieści się w int i wynik psuje się, zanim trafi do x. Poprawnie: 1LL * a * a.
W zadaniu n ≤ 1000. Liczysz n · n · n. Jaki typ?
??? w = n * n * n;
Pokaż odpowiedź
int wystarczy1000³ = 10⁹ — to mniej niż 2 147 483 647. Mieści się w int (ale już n ≤ 2000 dałoby 8 · 10⁹ i potrzebny byłby long long).

Co się dzieje, gdy typy się mieszają

Znasz już wszystkie podstawowe typy. Teraz zbierzmy w jednym miejscu, co się dzieje, gdy spotkają się w jednym działaniu — bo w prawdziwych zadaniach zdarza się to cały czas.

Zamiany automatyczne

Gdy w działaniu spotkają się int i double, C++ po cichu zamienia int na double i liczy na liczbach z przecinkiem — „mniejszy” typ dopasowuje się do „większego”. Podobnie int spotykający long long zamienia się na long long. Gorzej w drugą stronę: gdy wkładasz double do pudełka int, ułamek po prostu znika.

zamiany.cpp
int a = 5;
double b = 2.0;
cout << a / b << "\n";      // 2.5 — a zamieniło się na 5.0

double x = 7;               // int → double: x to 7.0
int y = 3.99;               // double → int: y to 3 (ułamek ucięty!)
cout << x << " " << y << "\n";
▶ Wyjście programu
2.5 7 3

Zamiana double na int nie zaokrągla, tylko ucina wszystko po kropce: 3.99 staje się 3, a −3.99 staje się −3.

Rzutowanie: zamiana na życzenie

Czasem trzeba zmienić typ świadomie. Wpisujesz wtedy nazwę typu w nawiasie przed wartością — to się nazywa rzutowanie. Używałeś go już przy znakach: (int)c i (char)k.

ZapisWynikCo się dzieje
(double)7 / 23.57 zamienia się na 7.0 przed dzieleniem
(int)3.993ucięcie ułamka, bez zaokrąglania
(int)-3.99-3ucina w stronę zera
(int)'a'97kod znaku w tabeli ASCII
(char)97aznak o podanym kodzie
(long long)a * b—mnożenie liczone od razu na long long

Gdzie postawić rzutowanie?

Rzutowanie działa na to, co stoi tuż za nim. Porównaj dwie bardzo podobne linijki:

gdzie_rzutowac.cpp
int suma = 7, ile = 2;
cout << (double)suma / ile << "\n";     // 3.5 — najpierw zamiana, potem dzielenie
cout << (double)(suma / ile) << "\n";   // 3   — najpierw dzielenie int-ów, potem zamiana
▶ Wyjście programu
3.5 3

W drugiej linijce nawias wymusza, żeby najpierw policzyć suma / ile — na int-ach, czyli 3 — i dopiero tę trójkę zamienić na double. Ułamek przepadł, zanim zdążyliśmy go uratować. Tak samo naprawisz przykład z części 05: double w = (double)a / b;.

Liczba ↔ napis

Liczba 42 i napis "42" to dla komputera zupełnie różne rzeczy: z liczbą można liczyć, a napis można sklejać i pytać o długość. Do zamiany służą gotowe funkcje:

ZapisZamianaPrzykład
to_string(x)liczba → napisto_string(42) daje "42"
stoi(s)napis → intstoi("42") daje 42
stoll(s)napis → long longstoll("10000000000") daje 10000000000
stod(s)napis → doublestod("2.5") daje 2.5
liczba_napis.cpp
int rok = 2026;
string s = to_string(rok);          // "2026"
cout << s.length() << "\n";         // 4 — tyle cyfr ma liczba!
cout << s + "!" << "\n";            // 2026!

string t = "12";
cout << stoi(t) * 2 << "\n";        // 24 — teraz to liczba
cout << t + t << "\n";              // 1212 — a to dwa sklejone napisy
cout << stoi(t + t) + 1 << "\n";    // 1213
▶ Wyjście programu
4 2026! 24 1212 1213

Ściągawka: wszystkie zamiany typów

ZamianaCo się dziejePrzykład
int → doubleAutomatyczna, bezstratna.double x = 5; daje 5.0
double → intUcina część ułamkową, nie zaokrągla.(int)2.9 daje 2
int / intDzielenie całkowite — ułamek przepada.7 / 2 daje 3
(double)a / bWystarczy zamienić jedną z dwóch liczb.(double)7 / 2 daje 3.5
int → long longDzieje się dopiero po obliczeniu — często za późno.long long x = a * b; może się przepełnić
1LL * a * bZmusza C++ do liczenia od razu na long long.działa nawet dla bardzo dużych a i b
char → intDaje numer znaku w tabeli ASCII.'a' to 97, c - '0' to cyfra
string → liczbastoi(s), dla dużych liczb stoll(s).stoi("42") daje 42
liczba → stringto_string(x).to_string(42) daje "42"
Sprawdź się w głowie

Ostatnie pytania przed bazą zadań.

Co wypisze ten fragment?
cout << (int)7.9 << " " << (int)-7.9;
Pokaż odpowiedź
7 -7Rzutowanie na int ucina ułamek w stronę zera — żadnego zaokrąglania do 8.
A ten?
int a = 9, b = 2;
cout << (double)a / b << " ";
cout << (double)(a / b);
Pokaż odpowiedź
4.5 4W pierwszym przypadku a zamienia się na double przed dzieleniem. W drugim najpierw liczy się 9 / 2 = 4 na int-ach.
Ile cyfr ma liczba?
cout << to_string(12345).length();
Pokaż odpowiedź
5to_string(12345) to napis „12345”, który ma 5 znaków.
Co wypisze ten fragment?
string x = "5", y = "6";
cout << stoi(x) + stoi(y) << " " << x + y;
Pokaż odpowiedź
11 56stoi zamienia napisy na liczby, więc pierwsze to 5 + 6 = 11. Drugie to sklejenie dwóch napisów.

Baza zadań: cały temat w praktyce

Gratulacje — znasz już wszystkie podstawowe typy! Czas sprawdzić tę wiedzę na zadaniach, które łączą kilka zagadnień naraz. Zadania są ułożone od najłatwiejszego do najtrudniejszego: najpierw rozgrzewka, potem zadania średnie, a na końcu trudne — z pułapkami na zakres typów, sprytnymi sztuczkami i wielkim finałem, w którym przydadzą się wszystkie typy naraz.

Przy każdym zadaniu widać, jakich zagadnień używa. Jeśli coś brzmi obco, wróć do odpowiedniej części lekcji — mapa lekcji jest na górze strony. Zaliczone zadania sprawdzarka zapamiętuje w tej przeglądarce, więc tutaj też zobaczysz przy nich zielony znaczek.

Jak rozwiązywać zadania 1) Przeczytaj treść dwa razy. 2) Spójrz na ograniczenia: czy int wystarczy, czy potrzebny jest long long albo double? 3) Rozwiąż przykład na kartce, zanim napiszesz choć jedną linijkę. 4) Napisz program i przetestuj go u siebie na przykładzie. 5) Wyślij. Gdy utkniesz na dłużej niż kwadrans, otwórz wskazówkę — to nie wstyd, tak się uczy.
średnie

Średnie · zadania 7–18

Łączysz kilka zagadnień i musisz chwilę pomyśleć nad wzorem.

7 Monetyśrednie✓ zaliczone Wydaj resztę monetami 5, 2 i 1 zł — jak najmniejszą liczbą monet. int/% Rozwiąż 8 Pizza na spółkęśrednie✓ zaliczone Ile pizz zamówić, żeby nikt nie był głodny? Dzielenie w górę. intdzielenie w górę Rozwiąż 9 Doby, godziny i minutyśrednie✓ zaliczone Zamień liczbę minut na pełne doby, godziny i minuty. int/% Rozwiąż 10 Suma cyfrśrednie✓ zaliczone Wyciągnij cztery cyfry liczby i je dodaj. int/ 10% 10 Rozwiąż 11 Liczba od tyłuśrednie✓ zaliczone Odwróć kolejność cyfr liczby trzycyfrowej: 120 → 21. int/ 10% 10 Rozwiąż 12 Średnia prędkośćśrednie✓ zaliczone Kilometry i minuty → km/h. Uwaga: t / 60 na int-ach to często 0. doublerzutowaniesetprecision Rozwiąż 13 Kalkulator BMIśrednie✓ zaliczone Masa przez kwadrat wzrostu — centymetry trzeba zamienić na metry. double/ 100.0setprecision Rozwiąż 14 Rok przestępnyśrednie✓ zaliczone Podzielny przez 4, ale nie przez 100 — chyba że przez 400. bool&& i ||% Rozwiąż 15 Kto pierwszy w dzienniku?średnie✓ zaliczone Porównaj dwa nazwiska alfabetycznie — operatorem < na stringach. string<bool Rozwiąż 16 Słowo w ramceśrednie✓ zaliczone Otocz słowo ramką z gwiazdek. Przyda się string(n, c) i .length(). stringstring(n, c).length() Rozwiąż 17 Pole trójkątaśrednie✓ zaliczone a · h / 2 dla boków do 100 000 — iloczyn przepełni int-a. doubleprzepełnienierzutowanie Rozwiąż 18 Kwadrat sumyśrednie✓ zaliczone (a + b)² dla liczb do miliarda — już sama suma nie mieści się w int. long longprzepełnienie Rozwiąż

Częste błędy i dobre praktyki

📣
Żadnego „Podaj liczbę:”
Sprawdzarka porównuje wyjście znak po znaku. Wypisuj tylko to, o co prosi zadanie — bez zaproszeń, komentarzy i polskich liter.
;
Średnik na końcu
Każde polecenie kończy się ;. Gdy kompilator zgłasza błąd, sprawdź podaną linijkę i tę nad nią — brakujący średnik często wychodzi dopiero w następnym wierszu.
⚖️
= to nie jest ==
Pojedyncze = wkłada wartość do zmiennej, a podwójne == sprawdza, czy dwie rzeczy są równe. W porównaniach zawsze piszemy ==.
➗
Dzielenie int / int
Dzielenie dwóch int-ów obcina ułamek: 7 / 2 to 3. Żeby dostać 3.5, jedna z liczb musi być double: 7 / 2.0 albo (double)a / b.
🔢
Przepełnienie int-a
int kończy się w okolicach 2 miliardów. Wstaw największe liczby z ograniczeń do wzoru — jeśli wynik może przekroczyć tę granicę, użyj long long, i to od razu przy wczytywaniu.
🔤
char vs string
char to pojedynczy znak w apostrofach: 'a'. string to napis w cudzysłowie: "a". Pomylenie ich to częsty błąd kompilacji.
0️⃣
Liczymy od zera
Pierwsza litera napisu to s[0], a ostatnia to s[s.length() - 1]. Zapis s[s.length()] wychodzi już poza napis.
✅
bool wypisuje się jako 1 i 0
cout pokazuje true jako 1, a false jako 0. Żeby zobaczyć słowa, wypisz wcześniej boolalpha. Porównanie w cout zawsze bierz w nawias.
🎯
double zamiast float
float pamięta tylko 6–7 pierwszych cyfr liczby. Na co dzień używaj double, a liczby double wypisuj z fixed i setprecision.
📏
Kropka, nie przecinek
W C++ liczby z ułamkiem piszemy z kropką: 3.14. Zapis 3,14 nie zrobi tego, czego się spodziewasz.
🔒
const chroni przed błędami
Wartości, które nie powinny się zmieniać, oznacz jako const. Kompilator wychwyci przypadkowe nadpisanie, zanim program w ogóle ruszy.
🗒️
Śledź program na kartce
Gdy wynik się nie zgadza, wypisz w tabelce wartości zmiennych po każdej linijce. Prawie zawsze od razu widać, gdzie program robi coś innego, niż myślałeś.

Co dalej?

Następna lekcja to Input / Output: szybkie wczytywanie danych, całe wiersze tekstu i formatowanie wyników. A jeśli chcesz trenować z mentorami — dołącz do T-Olimpians.