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ć.
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.
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.
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ś.
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.
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:
| Werdykt | Co znaczy | Co zrobić |
|---|---|---|
Accepted | Wszystkie testy przeszły — zadanie zaliczone. | Brawo! Bierz następne. |
Wrong answer | Program działa, ale wypisał coś innego, niż trzeba. | Porównaj swoje wyjście z oczekiwanym — sprawdzarka pokazuje oba obok siebie. |
Compilation error | Kod się nie skompilował: literówka, brak średnika albo klamry. | Przeczytaj komunikat — podaje numer linii z błędem. |
Runtime error | Program przerwał działanie w trakcie. | W tej lekcji to rzadkość — zwykle oznacza dzielenie przez zero. |
Time limit exceeded | Program liczył za długo. | W tej lekcji praktycznie się nie zdarza. |
int n;
cout << "Podaj liczbe: ";
cin >> n;
cout << "Podwojona liczba to " << n * 2;
int n;
cin >> n;
cout << n * 2 << "\n";
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.
#include <iostream>
using namespace std;
int main() {
cout << "Czesc!";
return 0;
}
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:
cout << "Ala";
cout << "ma kota";
cout << "Ala\n";
cout << "ma kota\n";
"\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.
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
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łowie | Na ekranie pojawi się |
|---|---|
\n | przejście do nowej linii |
\\ | jeden backslash: \ |
\" | cudzysłów: " |
\t | tabulator (kilka spacji) |
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.
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.
Najpierw odpowiedz sam — w myślach albo na kartce — a dopiero potem kliknij „Pokaż odpowiedź”.
cout << "3 * 3";
Pokaż odpowiedź
cout << 3 * 3 << 3 + 3;
Pokaż odpowiedź
cout << "Raz";
cout << "Dwa\n";
cout << "Trzy";
Pokaż odpowiedź
\n, więc „Dwa” dokleja się w tym samym wierszu. Dopiero \n po „Dwa” przenosi „Trzy” niżej.cout << "Czesc!"
Pokaż odpowiedź
;. Program się nie skompiluje, a kompilator zgłosi błąd w tej albo w następnej linii.4 ćwiczenia do tej części
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ę.
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ą.
#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;
}
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.
int wiek = 14;
cout << "wiek" << "\n"; // słowo wiek
cout << wiek << "\n"; // zawartość pudełka
int a = 5;
int b = 7;
cout << a + b << "\n";
cout << a * b << "\n";
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.
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
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:
int a = 3;
int b = 4;
a = a + b;
b = a * 2;
a = b - 10;
cout << a << " " << b << "\n";
| Po linijce | a | b |
|---|---|---|
int a = 3; | 3 | — |
int b = 4; | 3 | 4 |
a = a + b; | 7 | 4 |
b = a * 2; | 7 | 14 |
a = b - 10; | 4 | 14 |
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:
| Nazwa | Czy wolno? | Dlaczego |
|---|---|---|
wiek | ✅ tak | zwykłe małe litery — najprościej |
liczbaPunktow | ✅ tak | kilka słów sklejonych, każde kolejne z wielkiej litery |
liczba_punktow | ✅ tak | podkreślnik też jest dozwolony |
x2 | ✅ tak | cyfry wolno, byle nie na początku |
2gracz | ❌ nie | nazwa nie może zaczynać się od cyfry |
moja zmienna | ❌ nie | w nazwie nie może być spacji |
łódź | ❌ nie | bez polskich liter |
int | ❌ nie | to 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.
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.
Rozpisz wartości zmiennych w tabelce, tak jak w przykładzie wyżej.
int x = 5;
x = 8;
cout << x;
Pokaż odpowiedź
int x = 5;
x = x * 2;
x = x + 1;
cout << x;
Pokaż odpowiedź
int a = 2;
int b = a;
a = 10;
cout << b;
Pokaż odpowiedź
int x = 3;
cout << "x" << x;
Pokaż odpowiedź
2 ćwiczenia do tej części
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ę.
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.
#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;
}
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.
cout << x — z x na ekran. cin >> x — z klawiatury do x.
Kilka liczb naraz
int a, b; // dwa pudełka w jednej linijce
cin >> a >> b; // najpierw do a, potem do b
cout << a + b << "\n";
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
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
#include <iostream>
using namespace std;
int main() {
int m;
cin >> m;
cout << m * 60 << "\n";
return 0;
}
Przy każdym pytaniu podane jest wejście, które „wpisuje” sprawdzarka.
1 2. Co wypisze program?int a, b;
cin >> a >> b;
cout << b << a;
Pokaż odpowiedź
5 9. Co wypisze program?int x;
cin >> x;
x = x + 1;
cin >> x;
cout << x;
Pokaż odpowiedź
cin wkłada do x następną liczbę z wejścia, czyli 9. Szóstka przepada.int a = 1, b = 2;
a = b;
b = a;
cout << a << " " << b;
Pokaż odpowiedź
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!cin >> 5;
Pokaż odpowiedź
cin wkłada wczytaną wartość do pudełka, a 5 to nie pudełko, tylko liczba. Po prawej stronie >> zawsze stoi nazwa zmiennej.5 ćwiczeń do tej części
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ę.
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łanie | Zapis | Przykład | Wynik |
|---|---|---|---|
| dodawanie | a + b | 7 + 2 | 9 |
| odejmowanie | a - b | 7 - 2 | 5 |
| mnożenie | a * b | 7 * 2 | 14 |
| dzielenie całkowite | a / b | 7 / 2 | 3 |
| reszta z dzielenia | a % b | 7 % 2 | 1 |
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.
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
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).
| Zapis | Wynik | Dlaczego |
|---|---|---|
17 % 5 | 2 | 17 = 3 · 5 + 2 |
20 % 5 | 0 | 20 dzieli się przez 5 bez reszty |
3 % 5 | 3 | 3 = 0 · 5 + 3 |
2026 % 10 | 6 | reszta z dzielenia przez 10 to ostatnia cyfra |
n % 2 | 0 lub 1 | 0 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.
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
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.
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
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ót | Pełny zapis | Znaczy |
|---|---|---|
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.
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
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ń.
Policz na kartce, dopiero potem sprawdź.
cout << 17 / 5 << " " << 17 % 5;
Pokaż odpowiedź
cout << 10 - 2 * 3;
Pokaż odpowiedź
int x = 10;
x += 5;
x *= 2;
x--;
cout << x;
Pokaż odpowiedź
cout << 9 / 10 << " " << 9 % 10;
Pokaż odpowiedź
6 ćwiczeń do tej części
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ę.
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 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";
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:
| Zapis | Typy | Wynik |
|---|---|---|
7 / 2 | int / int | 3 |
7.0 / 2 | double / int | 3.5 |
7 / 2.0 | int / double | 3.5 |
7.0 / 2.0 | double / double | 3.5 |
Najbardziej podstępna wersja tej pułapki wygląda tak:
double wynik = 7 / 2;
cout << wynik << "\n"; // 3, a nie 3.5!
double dobrze = 7 / 2.0;
cout << dobrze << "\n"; // 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.
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>:
#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;
}
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
double a, b;
cin >> a >> b;
cout << fixed << setprecision(2);
cout << (a + b) / 2 << "\n";
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.
setprecision ładnie zaokrągla. Ale nigdy nie porównuj liczb double operatorem == — wrócimy do tego w części o bool.
Uważaj na typy liczb w każdym dzieleniu.
cout << 5 / 2 << " " << 5 / 2.0;
Pokaż odpowiedź
double x = 9 / 4;
cout << x;
Pokaż odpowiedź
cout << fixed << setprecision(2) << 7 / 3.0;
Pokaż odpowiedź
int a = 7, b = 2;
double w = a / b;
cout << w;
Pokaż odpowiedź
4 ćwiczenia do tej części
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ę.
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', '!'.
char litera = 'K';
char cyfra = '7';
char znak = '?';
cout << litera << cyfra << znak << "\n";
'a', "a" i a — trzy różne rzeczy
| Zapis | Co to jest | Uwagi |
|---|---|---|
'a' | znak (char) | dokładnie jeden znak, w apostrofach |
"a" | napis (string) | tekst w cudzysłowie — o napisach w następnej części |
a | nazwa zmiennej | bez 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ż.
| Znaki | Kody 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.
char c = 'A';
cout << (int)c << "\n"; // 65
cout << (char)66 << "\n"; // B
cout << (int)'7' << "\n"; // 55 — znak 7 to NIE liczba 7
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.
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
Najczęściej używana sztuczka ze znakami to odejmowanie. Różnica dwóch znaków to odległość między nimi w tabeli ASCII:
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
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.
Pamiętaj: znak + liczba = liczba.
cout << (char)('a' + 2);
Pokaż odpowiedź
(char) zamienia numer z powrotem na znak.cout << 'A' + 1;
Pokaż odpowiedź
(char) cout wypisuje numer, a nie literę B.char c = '5';
cout << c - '0' + 1;
Pokaż odpowiedź
char c = 'z';
cout << c - 'a' + 1;
Pokaż odpowiedź
6 ćwiczeń do tej części
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ę.
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>.
#include <iostream>
#include <string>
using namespace std;
int main() {
string imie = "Ola";
cout << "Czesc, " << imie << "!\n";
return 0;
}
Wczytywanie słowa
string imie, nazwisko;
cin >> imie >> nazwisko;
cout << nazwisko << " " << imie << "\n";
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.
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";
Długość napisu
string s = "olimpiada";
cout << s.length() << "\n"; // 9
cout << s.size() << "\n"; // 9 — to samo co length()
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" | b | a | j | t | e | k |
|---|---|---|---|---|---|---|
| numer | 0 | 1 | 2 | 3 | 4 | 5 |
| zapis | s[0] | s[1] | s[2] | s[3] | s[4] | s[5] |
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)
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.
cout << string(5, '*') << "\n";
string linia = string(12, '-');
cout << linia << "\n";
"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.
Pamiętaj: litery numerujemy od zera.
string s = "abc";
cout << s + s;
Pokaż odpowiedź
string s = "kajak";
cout << s.length() << s[1];
Pokaż odpowiedź
string a = "1", b = "2";
cout << a + b;
Pokaż odpowiedź
string s = "C++";
cout << s[s.length() - 1] << s[0];
Pokaż odpowiedź
5 ćwiczeń do tej części
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ę.
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 zdany = true;
int wiek = 17;
bool pelnoletni = (wiek >= 18); // porównanie daje false
cout << zdany << "\n";
cout << pelnoletni << "\n";
// 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";
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
| Zapis | Czyta się | Daje true, gdy… | Przykład |
|---|---|---|---|
a == b | a równe b | obie wartości są takie same | 3 == 3 → true |
a != b | a różne od b | wartości się różnią | 3 != 5 → true |
a < b | a mniejsze od b | a jest mniejsze | 2 < 5 → true |
a > b | a większe od b | a jest większe | 2 > 5 → false |
a <= b | a mniejsze lub równe b | a nie jest większe | 5 <= 5 → true |
a >= b | a większe lub równe b | a nie jest mniejsze | 4 >= 5 → false |
= 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”:
| Zapis | Czyta się | Daje true, gdy… | Przykład |
|---|---|---|---|
x && y | x oraz y | oba są true | n >= 10 && n <= 99 — liczba dwucyfrowa |
x || y | x lub y | przynajmniej jeden jest true | d == 6 || d == 7 — weekend |
!x | nie x | x jest false — odwraca odpowiedź | !(n > 100) — n nie jest większe od 100 |
| x | y | x && y | x || y |
|---|---|---|---|
| true | true | true | true |
| true | false | false | true |
| false | true | false | true |
| false | false | false | false |
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
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).
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:
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”
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ń.
true to 1, false to 0.
cout << (5 > 3) << (2 == 3);
Pokaż odpowiedź
cout << boolalpha << (7 % 2 == 1);
Pokaż odpowiedź
int x = 15;
cout << (x > 10 && x < 20);
cout << (x < 10 || x > 20);
Pokaż odpowiedź
cout << (3 > 2) + (2 > 1) + (1 > 0);
Pokaż odpowiedź
5 ćwiczeń do tej części
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ę.
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 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łą
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 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";
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.
Trzy krótkie pytania o stałe i auto.
const int X = 5;
cout << X * 2;
Pokaż odpowiedź
const int X = 5;
X = 6;
Pokaż odpowiedź
auto a = 5;
auto b = 2.0;
cout << a / 2 << " " << a / b;
Pokaż odpowiedź
2 ćwiczenia do tej części
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ę.
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ę:
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ół
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 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";
Pułapka: liczy się typ działania, nie wyniku
Ten przykład zaskakuje prawie wszystkich:
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";
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.
Wszystkie typy w jednej tabeli
Całej tabeli nie musisz znać na pamięć — na start wystarczą wiersze z int, long long i double.
| Typ | Rozmiar | Zakres | Kiedy używać |
|---|---|---|---|
bool | 1 bajt | false / true | odpowiedź „tak/nie” |
char | 1 bajt | -128 … 127 | jeden znak: litera, cyfra, przecinek |
short | 2 bajty | -32 768 … 32 767 | prawie nigdy — int jest wygodniejszy |
int | 4 bajty | -2 147 483 648 … 2 147 483 647 | Twój domyślny typ na liczby całkowite |
unsigned int | 4 bajty | 0 … 4 294 967 295 | tylko liczby nieujemne — na start omijaj |
long long | 8 bajtów | -9,22·10¹⁸ … 9,22·10¹⁸ | gdy liczba przekracza 2 miliardy |
unsigned long long | 8 bajtów | 0 … 1,84·10¹⁹ | bardzo duże liczby nieujemne — rzadko |
float | 4 bajty | ~7 cyfr znaczących | mało dokładny — lepiej weź double |
double | 8 bajtów | ~15–16 cyfr znaczących | Twój domyślny typ na liczby z przecinkiem |
long double | 16 bajtów | ~18–19 cyfr znaczących | gdy double nie wystarcza — rzadkość |
string | zmienny | dowolna długość tekstu | imię, słowo albo całe zdanie |
Granice w programie: INT_MAX i sizeof
#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;
}
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 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.
Int czy long long? Wstaw największe możliwe liczby.
int x = 3000000000;
Pokaż odpowiedź
??? w = a * b;
Pokaż odpowiedź
int a = 50000;
long long x = a * a;
Pokaż odpowiedź
??? w = n * n * n;
Pokaż odpowiedź
4 ćwiczenia do tej części
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ę.
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.
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";
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.
| Zapis | Wynik | Co się dzieje |
|---|---|---|
(double)7 / 2 | 3.5 | 7 zamienia się na 7.0 przed dzieleniem |
(int)3.99 | 3 | ucięcie ułamka, bez zaokrąglania |
(int)-3.99 | -3 | ucina w stronę zera |
(int)'a' | 97 | kod znaku w tabeli ASCII |
(char)97 | a | znak 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:
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
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:
| Zapis | Zamiana | Przykład |
|---|---|---|
to_string(x) | liczba → napis | to_string(42) daje "42" |
stoi(s) | napis → int | stoi("42") daje 42 |
stoll(s) | napis → long long | stoll("10000000000") daje 10000000000 |
stod(s) | napis → double | stod("2.5") daje 2.5 |
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
Ściągawka: wszystkie zamiany typów
| Zamiana | Co się dzieje | Przykład |
|---|---|---|
int → double | Automatyczna, bezstratna. | double x = 5; daje 5.0 |
double → int | Ucina część ułamkową, nie zaokrągla. | (int)2.9 daje 2 |
int / int | Dzielenie całkowite — ułamek przepada. | 7 / 2 daje 3 |
(double)a / b | Wystarczy zamienić jedną z dwóch liczb. | (double)7 / 2 daje 3.5 |
int → long long | Dzieje się dopiero po obliczeniu — często za późno. | long long x = a * b; może się przepełnić |
1LL * a * b | Zmusza C++ do liczenia od razu na long long. | działa nawet dla bardzo dużych a i b |
char → int | Daje numer znaku w tabeli ASCII. | 'a' to 97, c - '0' to cyfra |
string → liczba | stoi(s), dla dużych liczb stoll(s). | stoi("42") daje 42 |
liczba → string | to_string(x). | to_string(42) daje "42" |
Ostatnie pytania przed bazą zadań.
cout << (int)7.9 << " " << (int)-7.9;
Pokaż odpowiedź
int a = 9, b = 2;
cout << (double)a / b << " ";
cout << (double)(a / b);
Pokaż odpowiedź
cout << to_string(12345).length();
Pokaż odpowiedź
string x = "5", y = "6";
cout << stoi(x) + stoi(y) << " " << x + y;
Pokaż odpowiedź
5 ćwiczeń do tej części
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ę.
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.
Rozgrzewka · zadania 1–6
Jedno, dwa zagadnienia naraz — sprawdź, czy pamiętasz podstawy.
Średnie · zadania 7–18
Łączysz kilka zagadnień i musisz chwilę pomyśleć nad wzorem.
Trudne · zadania 19–26
Pułapki z zakresem typów, sprytne sztuczki i wielki finał.