Lidsky řečeno
Proměnná je krabice s popiskem a pevným tvarem. Do krabice na ponožky (int) nenacpeš slona (double s desetinami) bez toho, aby ti část nevypadla. C++ je přísné: každá krabice má typ a ten se po celou dobu života nemění. Klíčové slovo auto je říkání „typ si domysli podle toho, co do krabice dávám“.
Obtížnost: 2 z 5.
Základní typy
| Typ | K čemu | Poznámka |
|---|---|---|
int | celé číslo | typicky 32 bitů, velikost záleží na platformě |
long long | větší celé číslo | aspoň 64 bitů |
unsigned int | celé číslo bez znaménka | nikdy záporné, při přetečení se „obtočí“ |
double | desetinné číslo | dvojitá přesnost, obvykle výchozí volba |
float | desetinné číslo | menší přesnost |
char | jeden znak | velikost 1 bajt, zapisuje se 'A' |
bool | pravda / nepravda | hodnoty true, false |
std::string | text | z hlavičky <string> |
Když potřebuješ přesnou šířku (třeba přesně 32 bitů), použij <cstdint>: std::int32_t, std::uint8_t, std::int64_t. Standard u základních typů zaručuje jen minimální rozsah, proto se na velikost int nespoléhej.
Deklarace a inicializace
#include <iostream>
int main() {
int a = 10;
double b = 3.5;
auto c = a + b;
auto d = a / 4;
std::cout << c << "\n";
std::cout << d << "\n";
}13.5
2a + b je int plus double, výsledek je double, proto 13.5. a / 4 jsou dvě celá čísla, výsledek je int, tedy 2. auto vždy odvodí typ při překladu z pravé strany. Není to dynamický typ jako v Pythonu: c je od teď napořád double.
Proměnnou lze inicializovat třemi způsoby:
int x = 5; // klasicky
int y(6); // závorky
int z{7}; // složené závorky (doporučené v moderním C++)
int w{}; // prázdné závorky = nulaSložené závorky mají výhodu: zakážou ztrátové převody. int q{3.5}; se nepřeloží (zúžení typu, anglicky narrowing), kdežto int q = 3.5; projde a tiše zahodí desetinnou část.
Co vypíše program?
Převody typů a úskalí
Při převodu desetinného čísla na celé se ořízne k nule (ne zaokrouhlí). U typů bez znaménka a malých typů se hodnota obtáčí (modulo).
#include <iostream>
int main() {
double x = 9.99;
int i = x;
int j = static_cast<int>(-2.7);
unsigned char c = 255;
c = c + 1;
std::cout << i << " " << j << " " << static_cast<int>(c) << "\n";
}9 -2 0int i = x; zahodí .99, vznikne 9. static_cast<int>(-2.7) je -2 (ořez k nule). c + 1 se spočítá jako int (256) a při uložení zpět do unsigned char se hodnota zmenší modulo 256, výsledek je 0. Výpis přes static_cast<int>, jinak by cout vypsal znak, ne číslo.
Převody píšeme explicitně přes static_cast<typ>(hodnota). Je lépe viditelný než starý céčkový (int)x a dá se snadno najít.
Převody a ořez
const a constexpr
const říká „po inicializaci se hodnota nesmí měnit“. constexpr je silnější: hodnota se musí dát spočítat už při překladu.
#include <iostream>
constexpr int sq(int x) { return x * x; }
int main() {
constexpr int k = sq(6);
const int n = 4;
std::cout << k + n << "\n";
}40k je 36, n je 4, součet je 40. Zápis n = 5; by se nepřeložil, protože n je konstanta. Konstanty používej všude, kde se hodnota nemá měnit: překladač ti pak pomůže hlídat chyby a program se lépe čte.
auto a jeho pravidla
auto x = 5;jeint,auto y = 5.0;jedouble,auto z = 5.0f;jefloat.auto s = "ahoj";nenístd::string, ale ukazatelconst char*. Prostd::stringnapiš typ, nebo použij literál"ahoj"s(pousing namespace std::string_literals;).autozahodíconsta referenci:const int a = 1; auto b = a;je obyčejnéint(kopie), které se dá měnit.autose hodí u dlouhých názvů typů (iterátory) a u cyklů. U jednoduchých typů je často lepší napsat typ výslovně, aby bylo vidět, co čekáš.
Jaký typ odvodí auto?
Spoj typ s použitím
Ke každému typu najdi nejlepší použití.
Přeloží se, nebo ne?
Roztřiď řádky (každý je samostatně v těle funkce main).
Jaký typ má proměnná auto x = 3 / 2.0;?
Dělení je mezi int a double, výsledek je double (hodnota 1.5).
Co udělá int n = 7.99;?
Převod double na int ořezává k nule. Zaokrouhlovat musíš sám, například pomocí std::round.
Co je správně o constexpr?
constexpr je „konstanta známá při překladu“, funkce označená constexpr se smí vyhodnotit při překladu.
Co vypíše std::cout << (5 > 3) << (5 < 3);?
bool se vypisuje jako 1 nebo 0, pokud nepoužiješ std::boolalpha. 5 > 3 je 1, 5 < 3 je 0.
Pod kapotou · Co zaručuje standard a co ne
Standard definuje minimální rozsahy typů: int aspoň 16 bitů (prakticky 32), long long aspoň 64. Velikosti zjistíš přes sizeof a rozsahy přes std::numeric_limits<T> z <limits>. Znaménkový char je implementačně závislý (signed na x86 u GCC, unsigned často na ARM). Přetečení u znaménkových celých čísel je nedefinované chování, což umožňuje optimalizace (překladač smí předpokládat, že i + 1 > i). Od C++20 jsou celá čísla se znaménkem uložena v doplňkovém kódu (two's complement), ale přetečení zůstává nedefinované. Nástroje na hledání: -fsanitize=undefined u GCC a Clang zachytí přetečení za běhu.