Proměnné. Kolik datových typů "váží" Proměnná short

Když píšete program v jakémkoli jazyce, musíte použít různé proměnné pro uložení různých informací. Proměnné nejsou nic jiného než vyhrazená paměťová místa pro ukládání hodnot. To znamená, že když vytvoříte proměnnou, ušetříte nějaké místo v paměti.

Můžete ukládat informace různých datových typů, jako je znak, široký znak, celé číslo, pohyblivá řádová čárka, dvojitá pohyblivá řádová čárka, booleovská čárka atd. Na základě datového typu proměnné operační systém alokuje paměť a rozhodne, co lze uložit do rezervovaná paměť.

Primitivní vestavěné typy

C++ nabízí programátorovi bohatou sadu vestavěných i uživatelsky definovaných datových typů. Následující tabulky uvádí sedm hlavních datových typů C++:

Některé ze základních typů lze upravit pomocí jednoho nebo více modifikátorů daného typu:

• podepsaný
• nepodepsaný
• krátký

Následující tabulka ukazuje typ proměnné, množství paměti potřebné k uložení hodnoty do paměti a jaké jsou maximální a minimální hodnoty, které lze do těchto proměnných uložit.

Velikost proměnných se může lišit od velikosti uvedené v tabulce výše v závislosti na kompilátoru a počítači, který používáte. Níže je uveden příklad, který poskytne správnou velikost pro různé typy dat ve vašem počítači.

#zahrnout pomocí jmenného prostoru std; int main() ( cout<< "Size of char: " << sizeof(char) << endl; cout << "Size of int: " << sizeof(int) << endl; cout << "Size of short int: " << sizeof(short int) << endl; cout << "Size of long int: " << sizeof(long int) << endl; cout << "Size of float: " << sizeof(float) << endl; cout << "Size of double: " << sizeof(double) << endl; cout << "Size of wchar_t: " << sizeof(wchar_t) << endl; return 0; }

Tento příklad používá endl, který za každým řádkem zavádí znak nového řádku, a operátor<< используется для передачи нескольких значений на экран. Мы также используем оператор velikost() získat velikost různých datových typů.

Když je výše uvedený kód zkompilován a spuštěn, vytvoří následující výstup, který se může lišit stroj od stroje:

Velikost char: 1 Velikost int: 4 Velikost krátké int: 2 Velikost dlouhé int: 4 Velikost plováku: 4 Velikost double: 8 Velikost wchar_t: 4

deklarace typedef

Pomocí definice typu můžete vytvořit nový název pro existující typ. Následuje jednoduchá syntaxe pro definování nového typu pomocí typedef:

Typedef typ newname;

Například následující text říká kompilátoru, že feet je jiný název pro int:

Typedef int nohy;

Nyní je následující deklarace naprosto legální a vytváří celočíselnou proměnnou s názvem vzdálenost:

Vzdálenost nohou;

Uvedené typy

Výčtový typ deklaruje volitelný název typu a sadu nula nebo více identifikátorů, které lze použít jako hodnoty typu. Každý enumerátor je konstanta, jejíž typ je enum. K vytvoření výčtu je nutné použití klíčového slova. enum. Celkový pohled na typ výčtu:

Enum enum-name ( seznam jmen ) var-list;

Zde enum-name je název typu enum. Seznam jmen je oddělen čárkou. Například následující kód definuje výčet barev nazývaných barvy a proměnnou c typu color. Nakonec je c přiřazena hodnota "modrá".

Barva výčtu ( červená, zelená, modrá ) c; c = modrá;

Ve výchozím nastavení je hodnota prvního jména 0, druhé jméno má hodnotu 1 a třetí jméno má hodnotu 2 atd. Můžete však zadat název, konkrétní hodnotu, přidáním inicializátoru . Například v následujícím výčtu by zelená měla hodnotu 5.

Barva výčtu ( červená, zelená = 5, modrá );

Modrá zde bude mít hodnotu 6, protože každé jméno bude větší než předchozí.

V této lekci se podíváme na celočíselné datové typy, jejich rozsahy hodnot, dělení a přetečení: co to je a příklady.

Integer datové typy

celočíselný datový typ je typ, jehož proměnné mohou obsahovat pouze celá čísla (bez zlomkové části, například: -2, -1, 0, 1, 2). C++ má k dispozici pět základních celočíselných typů:

Poznámka: Typ char je speciální případ, je to datový typ celé číslo i znak. O tom si povíme podrobněji v některé z příštích lekcí.

Hlavní rozdíl mezi výše uvedenými celočíselnými typy je jejich , čím větší je, tím více hodnot bude proměnná tohoto typu schopna uložit.

Definování celočíselných proměnných

Stává se to takto:

char c; krátké int si; // platné krátké s; // s výhodou int i; dlouhé intli; // platné dlouhé l; // nejlépe long long int lli; // platný long long ll; // preferováno

I když lze použít celá jména short int , long int a long long int , preferují se jejich zkrácené verze (bez int ). Neustálé přidávání int navíc znesnadňuje čtení kódu (snadno zaměnitelné s proměnnou).

Rozsahy hodnot a znaménko celočíselných datových typů

Jak již víte z předchozí lekce, do proměnné s n bity lze uložit 2n možných hodnot. Ale jaké jsou tyto hodnoty? Ty, které jsou v dosahu. Rozsah jsou hodnoty, od kterých a do kterých může konkrétní datový typ uložit. Rozsah celočíselné proměnné je určen dvěma faktory: její velikostí (v bitech) a její podepsat(což může být podepsaný nebo nepodepsaný).

Typ celého čísla se znaménkem (podepsaný) znamená, že proměnná může obsahovat kladná i záporná čísla. Chcete-li proměnnou deklarovat jako podepsanou, použijte klíčové slovo podepsané:

podepsané char c; podepsané šortky; podepsané int i; signováno longl; podepsáno dlouhé dlouhé ll;

Ve výchozím nastavení se klíčové slovo podepsané zapisuje před datový typ.

Jednobajtová celočíselná proměnná se znaménkem má rozsah hodnot -128 až 127. Lze do ní bezpečně uložit jakoukoli hodnotu od -128 do 127 (včetně).

V některých případech můžeme předem vědět, že v programu nebudou použita záporná čísla. To je velmi běžné při použití proměnných k uložení množství nebo velikosti něčeho (například vaše výška nebo váha nemůže být záporná).

celočíselný typ nepodepsaný (nepodepsaný) může obsahovat pouze kladná čísla. Chcete-li deklarovat proměnnou jako nepodepsaný, použijte klíčové slovo bez znaménka:

unsigned char c; nepodepsané šortky; unsigned int i; nesignováno dlouhé l; nesignováno dlouhý dlouhý ll;

Jednobajtová celočíselná proměnná bez znaménka má rozsah hodnot od 0 do 255.

Všimněte si, že deklarace proměnné jako bez znaménka znamená, že nemůže obsahovat záporná čísla (pouze kladná).

Nyní, když rozumíte rozdílu mezi podepsaným a nepodepsaným, se podívejme na rozsahy hodnot různých typů dat:

Pro matematiky: proměnná se znaménkem s n bity má rozsah -(2 n-1) až 2 n-1 -1. Proměnná bez znaménka s n bity má rozsah 0 až (2n)-1. Pro nematematiky: použijte tabulku 🙂

Začínající programátoři se někdy zaměňují mezi podepsanými a nepodepsanými proměnnými. Existuje však snadný způsob, jak si jejich rozdíly zapamatovat. Jaký je rozdíl mezi záporným a kladným číslem? Že jo! Mínus vepředu. Pokud není žádné mínus, pak je číslo kladné. Typ celého čísla se znaménkem tedy znamená, že může být přítomno mínus, tzn. čísla mohou být kladná i záporná. Typ celého čísla bez znaménka znamená, že mínus v popředí zcela chybí, tzn. čísla mohou být pouze kladná.

Co je výchozí: podepsané nebo nepodepsané?

Co se tedy stane, když deklarujeme proměnnou, aniž bychom uvedli podepsané nebo nepodepsané?

Všechny celočíselné datové typy kromě char jsou standardně podepsány. Typ char může být buď podepsaný, nebo nepodepsaný (obvykle však podepsaný).

Ve většině případů se podepsané klíčové slovo nezapisuje (je již standardně používáno), kromě typu char (zde lépe upřesnit).

Programátoři se obecně vyhýbají používání celočíselných typů bez znaménka, pokud to není nezbytně nutné, protože proměnné bez znaménka jsou statisticky náchylnější k chybám než proměnné se znaménkem.

Pravidlo: Použijte typy celých čísel se znaménkem, namísto nepodepsaný.

Přetékat

Otázka: "Co se stane, když se pokusíme použít hodnotu, která je mimo rozsah hodnot konkrétního datového typu?". Odpověď: Přetečení.

Přetékat(Angličtina) "přetékat") dochází, když jsou bity ztraceny, protože proměnné nebylo přiděleno dostatek paměti pro jejich uložení.

Příklady přetečení

Uvažujme proměnnou bez znaménka, která se skládá ze 4 bitů. Do této proměnné se vejde kterékoli z binárních čísel uvedených v tabulce výše.

"Co se ale stane, když se pokusíme přiřadit hodnotu, která trvá více než 4 bity?" Že jo! Přetékat. Naše proměnná bude ukládat pouze 4 nejméně významné (ty napravo) bity, všechny ostatní budou ztraceny.

Pokud se například pokusíme vložit číslo 21 do naší 4bitové proměnné:

Číslo 21 trvá 5 bitů (10101). 4 bity napravo (0101) se vejdou do proměnné a bit zcela vlevo (1) se jednoduše ztratí. Tito. naše proměnná bude obsahovat 0101, což se rovná 101 (nula vpředu se nebere v úvahu), a to je číslo 5, nikoli 21.

Poznámka: O převodu čísel z binárních na desítkové a naopak bude samostatná lekce, kde vše podrobně zvážíme a probereme.

Nyní se podívejme na příklad v kódu (krátký typ trvá 16 bitů):

#zahrnout int main() ( unsigned short x = 65535; // největší hodnota, kterou může 16bitová proměnná bez znaménka uložit std::cout<< "x was: " << x << std::endl; x = x + 1; // 65536 - это число больше максимально допустимого числа из диапазона допустимых значений. Следовательно, произойдёт переполнение, так как переменнная x не может хранить 17 бит std::cout << "x is now: " << x << std::endl; return 0; }

x bylo: 65535
x je nyní: 0

Co se stalo? Došlo k přetečení, protože jsme se pokusili nacpat něco, co nelze vměstnat do x .

Pro ty, kteří chtějí vědět více:Číslo 65 535 je binárně reprezentováno jako 1111 1111 1111 1111. 65 535 je největší číslo, které může uložit 2bajtová (16bitová) celočíselná proměnná bez znaménka, protože používá všech 16 bitů. Když sečteme 1, dostaneme číslo 65536. Číslo 65536 je binárně reprezentováno jako 1 0000 0000 0000 0000 a zabírá 17 bitů! Proto je nejvýznamnější bit (což je 1) ztracen, zatímco všech 16 bitů vpravo je vlevo. Kombinace 0000 0000 0000 0000 odpovídá desetinné 0, což je náš výsledek.

Podobně získáme přetečení použitím čísla menšího, než je minimum z rozsahu platných hodnot:

#zahrnout int main() ( unsigned short x = 0; // nejmenší hodnota 2bajtová unsigned proměnná může obsahovat std::cout<< "x was: " << x << std::endl; x = x - 1; // переполнение! std::cout << "x is now: " << x << std::endl; return 0; }

Výsledek spuštění výše uvedeného programu je:

x bylo: 0
x je nyní: 65535

Přetečení vede ke ztrátě informací, a to není nikdy vítáno. Pokud existuje sebemenší podezření nebo náznak, že hodnota proměnné může být číslo, které je mimo rozsah platných hodnot použitého datového typu - použijte větší datový typ!

Tento cheat sheet poskytuje informace o hlavních datových typech programovacího jazyka C++ a funkcích jejich implementace. Na konci záznamu je také tabulka s rozsahy hodnot těchto typů.

Koncept datového typu

Hlavním účelem každého programu je zpracovávat data. Různé typy dat se ukládají a zpracovávají odlišně. V jakémkoli algoritmickém jazyce musí mít každá konstanta, proměnná, výraz nebo výsledek vyhodnocení funkce určitý typ.

Datový typ definuje:

• Interní reprezentace dat v počítačové paměti;
• množina hodnot, které mohou hodnoty tohoto typu nabývat;
• operace a funkce, které lze na hodnoty tohoto typu aplikovat.

Na základě těchto charakteristik programátor zvolí typ každé hodnoty použité v programu k reprezentaci skutečných objektů. Povinná deklarace typu umožňuje kompilátoru kontrolovat platnost různých programových konstrukcí. Typ hodnoty určuje strojové instrukce, které budou použity ke zpracování dat.

Všechny typy jazyka C++ lze rozdělit na hlavní A kompozitní . C++ definuje šest hlavní, důležitý datové typy pro reprezentaci celočíselných, reálných, symbolických a logických hodnot. Na základě těchto typů může programátor zadat popis složka typy. Patří mezi ně pole, výčty, funkce, struktury, odkazy, ukazatele, sjednocení a třídy.

Základní datové typy v C++

Základní (standardní) datové typy se často nazývají aritmetické, protože je lze použít v aritmetických operacích. Pro popis hlavních typů jsou definovány následující:

1. int(celé číslo);
2. char (znak);
3. wchar_t (široký znak);
4. bool (booleovský);
5. plovák (skutečný);
6. double (skutečné s dvojnásobnou přesností).

První čtyři tingy se nazývají celé číslo ( Celý ), poslední dva typy s plovoucí desetinnou čárkou . Kód, který kompilátor generuje pro zpracování celočíselných hodnot, se liší od kódu pro hodnoty s plovoucí desetinnou čárkou.

Jsou čtyři specifikátor typu , určující vnitřní reprezentaci a rozsah hodnot standardních typů:

• krátký (krátký);
• dlouhý (dlouhý);
• podepsaný (podepsat);
• nepodepsaný (nepodepsaný).

Typ celého čísla (int)

Velikost typu int není definována standardem, ale závisí na počítači a kompilátoru. Pro 16bitový procesor jsou pro hodnoty tohoto typu přiděleny 2 bajty, pro 32bitový procesor - 4 bajty.

Krátký specifikátor před názvem typu říká kompilátoru, že číslo vyžaduje 2 bajty bez ohledu na kapacitu procesoru. Specifikátor long znamená, že celočíselná hodnota bude trvat 4 bajty. Na 16bitovém počítači jsou tedy ekvivalenty int a short int a na 32bitovém počítači int a long int.

Vnitřní zastoupení hodnoty typu integer - celé číslo v binárním kódu. Při použití specifikátoru se znaménkem je nejvýznamnější bit čísla interpretován jako znaménko (0 - kladné číslo, 1 - záporné). Specifikátor bez znaménka umožňuje zastoupení pouze kladných čísel, protože nejvýznamnější číslice je považována za součást kódu čísla. Rozsah hodnot typu int tedy závisí na specifikátorech. Rozsahy hodnot hodnot celočíselného typu s různými specifikátory pro počítače kompatibilní s IBM PC jsou uvedeny v tabulce "Rozsahy hodnot jednoduchých datových typů" na konci položky.

Ve výchozím nastavení jsou všechny typy celých čísel považovány za podepsané, což znamená, že specifikátor se znaménkem lze vynechat.

Konstantám, se kterými se program setká, je přiřazen jeden nebo jiný typ podle jejich typu. Pokud tento typ programátorovi z nějakého důvodu nevyhovuje, může požadovaný typ výslovně specifikovat pomocí koncovek L, l (dlouhý) a U, u (bez znaménka). Například konstanta 32L bude typu long a zabere 4 bajty. Přípony L a U můžete používat současně, například 0x22UL nebo 05Lu.

Poznámka

Typy short int, long int, signed int a unsigned int lze zkrátit na short, long, signed a unsigned.

Typ znaku (char)

Hodnota znakového typu je počet bajtů dostatečný k umístění libovolného znaku ze znakové sady pro daný počítač, který vedl k názvu typu. Obvykle je to 1 bajt. Typ char, stejně jako ostatní celočíselné typy, může být se znaménkem nebo bez znaménka. Hodnoty se znaménkem mohou ukládat hodnoty v rozsahu od -128 do 127. Při použití specifikátoru bez znaménka se hodnoty mohou pohybovat od 0 do 255. To stačí k uložení libovolného znaku ve znakové sadě ASCII o 256 znacích. Hodnoty typu char se také používají k ukládání celých čísel, která nepřesahují hranice zadaných rozsahů.

Rozšířený typ znaku (wchar_t)

Typ wchar_t je navržen pro práci se sadou znaků, pro které nestačí 1 bajt ke kódování, jako je Unicode. Velikost tohoto typu je závislá na implementaci; zpravidla odpovídá krátkému typu. Řetězcové konstanty typu wchar_t se zapisují s předponou L, například L"Gates".

Booleovský typ (bool)

Booleovské hodnoty mohou mít pouze hodnoty true a false, což jsou vyhrazená slova. Vnitřní reprezentace false je 0 (nula). Jakákoli jiná hodnota je interpretována jako pravdivá. Při převodu na celočíselný typ má true hodnotu 1.

Typy s pohyblivou řádovou čárkou (float, double a long double)

Standard C++ definuje tři datové typy pro ukládání skutečných hodnot: float, double a long double.

Datové typy s plovoucí desetinnou čárkou jsou v paměti počítače uloženy jinak než celočíselné datové typy. Vnitřní reprezentace reálného čísla se skládá ze dvou částí - mantisy a exponentu. Na počítačích kompatibilních s IBM PC zabírají hodnoty float 4 bajty, z nichž jeden bit je přidělen pro znaménko mantisy, 8 bitů pro exponent a 23 pro mantisu. Mantisa je číslo větší než 1,0, ale menší než 2,0. Protože nejvyšší číslice mantisy je vždy 1, neukládá se.

Pro hodnoty typu double, zabírající 8 bajtů, je pro objednávku a mantisu přiděleno 11 a 52 číslic. Délka mantisy určuje přesnost čísla, zatímco délka exponentu určuje jeho rozsah. Jak můžete vidět z tabulky na konci záznamu, při stejném počtu bajtů přidělených pro hodnoty float a long int se rozsahy jejich platných hodnot značně liší kvůli formě vnitřní reprezentace.

Specifikátor long před názvem typu double označuje, že pro jeho hodnotu je alokováno 10 bajtů.

Konstanty s pohyblivou řádovou čárkou jsou standardně typu double. Typ konstanty můžete explicitně určit pomocí přípon F, f (float) a L, l (long). Například konstanta 2E+6L by byla typu long double a konstanta 1,82f by byla typu float.

Chcete-li psát programy pro různé platformy, nemůžete dělat předpoklady o velikosti typu int. K jeho získání je potřeba použít operátor sizeof, který vrací velikost typu v bajtech. Například v operačním systému MS-DOS bude sizeof(int) mít za následek 2 a na Windows 98 nebo OS/2 bude výsledek 4.

Standard ANSI nespecifikuje rozsahy hodnot pro hlavní typy, jsou definovány pouze poměry mezi jejich velikostmi, například:

sizeof(float) ≤ slzeof(double) ≤ sizeof(long double)
sizeof(char) ≤ slzeof(short) ≤ sizeof(int) ≤ sizeof(long)

Poznámka

Minimální a maximální povolené hodnoty pro celočíselné typy jsou závislé na implementaci a jsou uvedeny v záhlaví souboru (), charakteristika reálných typů - ve spis (), stejně jako v šabloně třídy numeric_limits

prázdný typ

Kromě uvedených je typ void jedním z hlavních typů jazyka, ale sada hodnot tohoto typu je prázdná. Používá se k definování funkcí, které nevrací hodnotu, k určení prázdného seznamu argumentů funkcí, jako základního typu pro ukazatele a v operacích přetypování.

Rozsahy hodnot jednoduchých datových typů v C++ pro počítače kompatibilní s IBM PC

Q: Co znamená termín IBM PC-kompatibilní počítač?
A: Počítač kompatibilní s IBM PC (angl. IBM PC compatible) - počítač, který se architektonicky blíží IBM PC, XT a AT. Počítače kompatibilní s IBM PC jsou založeny na mikroprocesorech kompatibilních s Intel 8086 (a jak víte, všechny pozdější procesory Intel jsou plně zpětně kompatibilní s 8086). Ve skutečnosti jsou to téměř všechny moderní počítače.

Zavádějí se různé typy celočíselných a reálných typů, které se liší rozsahem a přesností reprezentace dat, aby programátor mohl co nejefektivněji využít možnosti konkrétního hardwaru, protože rychlost výpočtů a velikost paměti záleží na výběru typu. Ale program optimalizovaný pro jeden typ počítače se může stát nepřenosným na jiné platformy, takže obecně je třeba se vyvarovat závislostí na specifických vlastnostech datových typů.

U skutečných typů jsou v tabulce uvedeny absolutní hodnoty minimální a maximální hodnoty.

V jazyce C se rozlišují pojmy „datový typ“ a „modifikátor typu“. Datový typ je celé číslo a modifikátor je se znaménkem nebo bez znaménka. Celé číslo se znaménkem bude mít kladné i záporné hodnoty, zatímco celé číslo bez znaménka bude mít pouze kladné hodnoty. V jazyce C existuje pět základních typů.

• char - znak.

Proměnná typu char má velikost 1 bajt, její hodnoty jsou různé znaky z kódové tabulky, například: 'f', ':', 'j' (jsou-li zapsány v programu, jsou uzavřeny v jednoduchých uvozovkách ).

• int je celé číslo.

Velikost proměnné typu int není ve standardu C definována. Ve většině programovacích systémů velikost proměnné typu int odpovídá velikosti celého strojového slova. Například v kompilátorech pro 16bitové procesory má proměnná int velikost 2 bajty. V tomto případě se podepsané hodnoty této proměnné mohou pohybovat od -32768 do 32767.

• plovák je skutečný.

Klíčové slovo float umožňuje definovat proměnné s pohyblivou řádovou čárkou. Jejich hodnoty mají zlomkovou část oddělenou tečkou, například: -5,6, 31,28 atd. Reálná čísla lze také zapsat v plovoucí desetinné čárce, například: -1,09e+4. Číslo před symbolem "e" se nazývá mantisa a po "e" - pořadí. Proměnná float zabírá 32 bitů v paměti. Může nabývat hodnot v rozmezí od 3,4e-38 do 3,4e+38.

• double – skutečná dvojitá přesnost;

Klíčové slovo double umožňuje definovat skutečnou proměnnou s dvojitou přesností. Zabírá dvakrát více místa v paměti než proměnná float. Proměnná typu double může nabývat hodnot v rozsahu od 1,7e-308 do 1,7e+308.

• neplatný - nemá žádnou hodnotu.

Klíčové slovo void se používá k neutralizaci hodnoty objektu, například k deklaraci funkce, která nevrací žádnou hodnotu.

Typy proměnných:

Programy pracují s různými daty, která mohou být jednoduchá a strukturovaná. Jednoduchá data jsou celá a reálná čísla, symboly a ukazatele (adresy objektů v paměti). Celá čísla nemají a reálná čísla mají zlomkovou část. Strukturovaná data jsou pole a struktury; bude o nich pojednáno níže.

Proměnná je místo v paměti počítače, které má jméno a ukládá nějakou hodnotu. Hodnota proměnné se může během provádění programu změnit. Když je do buňky zapsána nová hodnota, stará hodnota se vymaže.

Je dobrým stylem pojmenovávat proměnné smysluplně. Název proměnné může obsahovat jeden až 32 znaků. Můžete použít malá a velká písmena, čísla a znak podtržení, který je v C považován za písmeno. První znak musí být písmeno. Název proměnné nemůže být stejný jako vyhrazená slova.

typ char

char je nejekonomičtější typ. Typ znaku může být podepsaný nebo nepodepsaný. Označuje se jako "signed char" (podepsaný typ) a "unsigned char" (nepodepsaný typ). Podepsaný typ může ukládat hodnoty v rozsahu -128 až +127. Bez znaménka - od 0 do 255. Pro proměnnou typu char je přidělen 1 bajt paměti (8 bitů).

Klíčová slova se znaménkem a bez znaménka udávají, jak je interpretován nulový bit deklarované proměnné, tj. pokud je specifikováno klíčové slovo bez znaménka, pak je nulový bit interpretován jako část čísla, jinak je nulový bit interpretován jako znaménko.

zadejte int

Celočíselná hodnota int může být krátká (krátká) nebo dlouhá (dlouhá). Krátké klíčové slovo je umístěno za podepsanými nebo nepodepsanými klíčovými slovy. Existují tedy typy: podepsané short int, unsigned short int, signované dlouhé int, unsigned long int.

Proměnná typu signature short int (signed short integer) může nabývat hodnot od -32768 do +32767, unsigned short int (unsigned short integer) - od 0 do 65535. Přesně dva bajty paměti (16 bitů) jsou alokovány pro každý z nich.

Při deklaraci proměnné typu sign short int lze klíčová slova sign a short vynechat a takový typ proměnné lze deklarovat jednoduše int. Tento typ je také možné deklarovat pomocí jediného krátkého klíčového slova.

Unsigned short int proměnná může být deklarována jako unsigned int nebo unsigned short.

Každý dlouhý int se znaménkem nebo dlouhý int bez znaménka má 4 bajty paměti (32 bitů). Hodnoty proměnných tohoto typu se mohou pohybovat od -2147483648 do 2147483647 a od 0 do 4294967295.

Existují také proměnné typu long long int, pro které je alokováno 8 bajtů paměti (64 bitů). Mohou být podepsané nebo nepodepsané. Pro typ se znaménkem je rozsah hodnot od -9223372036854775808 do 9223372036854775807, pro typ bez znaménka od 0 do 18446744073709551615. Typ se znaménkem lze také deklarovat jednoduše pomocí dvou dlouhých klíčových slov.

Deklarace proměnných

Proměnné jsou deklarovány v deklaračním příkazu. Příkaz deklarace se skládá ze specifikace typu a seznamu názvů proměnných oddělených čárkami. Na konci musí být středník.

[modifikátory] typespecifier id [, id] ...

Modifikátory jsou klíčová slova se znaménkem, bez znaménka, krátká, dlouhá.
Specifikátor typu je klíčové slovo char nebo int, které určuje typ deklarované proměnné.
Identifikátor je název proměnné.

Charx; int a, b, c; bez znaménka dlouhé dlouhé y;

Při deklaraci proměnné ji můžete inicializovat, to znamená přiřadit jí počáteční hodnotu.

int x = 100;

Do proměnné x se při deklaraci ihned zapíše číslo 100. Inicializované proměnné je lepší deklarovat na samostatných řádcích.

Datový typ v programování je kolekce dvou sad: sada hodnot a sada operací, které na ně lze použít. Například nezáporný celočíselný datový typ, který se skládá z konečné množiny přirozených čísel, lze použít na operace sčítání (+), násobení (*), dělení celého čísla (/), zbytek (%) a odčítání (-).

Programovací jazyk má obvykle sadu primitivních datových typů – typů poskytovaných programovacím jazykem jako základní vestavěná jednotka. V C++ nazývá tvůrce jazyka takové typy základními typy. Základní typy v C++ jsou:

• boolean (bool);
• znak (např. char);
• celé číslo (např. int);
• plovoucí desetinná čárka (např. plovoucí);
• výčty (definované programátorem);
• prázdnota

Kromě výše uvedeného jsou vytvořeny následující typy:

• ukazatele (např. int*);
• pole (např. char);
• odkaz (např. double&);
• jiné struktury.

Přejděme ke konceptu literálu (např. 1, 2.4F, 25e-4, ‚a‘ atd.): literál je záznam ve zdrojovém kódu programu, který představuje pevnou hodnotu. Jinými slovy, literál je jednoduše reprezentace objektu (hodnoty) nějakého typu v kódu programu. C++ má schopnost zapisovat celočíselné hodnoty, hodnoty s pohyblivou řádovou čárkou, znakové, booleovské, řetězcové hodnoty.

Literál typu celé číslo lze zapsat jako:

• 10. číselná soustava. Například 1205;
• 8. číselná soustava ve formátu 0 + číslo. Například 0142;
• 16. číselná soustava ve formátu 0x + číslo. Například 0x2F .

24, 030, 0x18 jsou všechny položky stejného čísla v různých číselných soustavách.
Pro zápis čísel s plovoucí desetinnou čárkou se používá tečkový zápis: 0,1, 0,5, 4. - buď v
exponenciální zápis - 25e-100. V takovém záznamu by neměla být žádná mezera.

Název, se kterým můžeme spojit hodnoty zapsané literály, se nazývá proměnná. Proměnná je pojmenované nebo jinak adresovatelné místo v paměti, jehož adresu lze použít pro přístup k datům. Tato data jsou během provádění programu určitým způsobem zapsána, přepsána a vymazána v paměti. Proměnná umožňuje kdykoli přistupovat k datům a v případě potřeby je měnit. Data, která lze načíst z názvu proměnné, se nazývají hodnota proměnné.
Aby bylo možné v programu použít proměnnou, musí být deklarována a v případě potřeby může být definována (= inicializována). Deklarace proměnné v textu programu nutně obsahuje 2 části: základní typ a deklarátor. Specifikátor a inicializátor jsou volitelné části:

const int příklad = 3; // zde const - specifikátor // int - základní typ // příklad - název proměnné // = 3 - inicializátor.

Název proměnné je posloupnost znaků z písmen latinské abecedy (malá a velká), čísel a/nebo podtržítek, ale první znak nemůže být číslice. Název proměnné by měl být zvolen tak, aby bylo vždy snadné uhodnout, co ukládá, například „monthPayment“. Abstraktně i v praxi budeme pro pravidla pro zápis proměnných používat notaci CamelCase. Název proměnné se nemůže shodovat se slovy vyhrazenými v jazyce, příklady takových slov: if, while, function, goto, switch atd.

Deklarátor může kromě názvu proměnné obsahovat další znaky:

• * - ukazatel; před jménem
• *const - konstantní ukazatel; před jménem
• & - odkaz; před jménem
• - pole; za jménem;
• () - funkce; za jménem.

Inicializátor umožňuje definovat hodnotu proměnné bezprostředně po deklaraci. Inicializátor začíná literálem rovná se (=) a poté probíhá proces nastavení hodnoty proměnné. Obecně řečeno, rovnítko v C++ označuje operaci přiřazení; lze jej použít k nastavení a změně hodnoty proměnné. U různých typů se může lišit.

Specifikátor určuje další atributy jiné než typ. Specifikátor const uvedený v příkladu umožňuje zakázat následné změny hodnoty proměnné. Takové neměnné proměnné se nazývají konstantní nebo konstantní.

Deklarování konstanty bez inicializace nebude fungovat z logických důvodů:

Const int EMPTY_CONST; // chyba, konstantní proměnná není inicializována const int PŘÍKLAD = 2; // konstanta s hodnotou 2 EXAMPLE = 3; // chyba, pokuste se přiřadit hodnotu konstantní proměnné

Pro pojmenování konstant je zvykem používat pouze velká písmena, slova oddělující znakem podtržítka.

Základní datové typy v C++

Při rozboru každého typu musí čtenář pamatovat na definování datového typu.

1. Typ celého čísla (char, short(int), int, long(int), long long)

Z názvu je snadné pochopit, že množina hodnot se skládá z celých čísel. Také sada hodnot každého z uvedených typů může být podepsána (podepsána) nebo nepodepsána (nepodepsána). Počet prvků obsažených v sadě závisí na velikosti paměti, která se používá k uložení hodnoty daného typu. Například pro proměnnou typu char je přidělen 1 bajt paměti, takže celkový počet prvků bude:

• 2 8N = 2 8 * 1 = 256, kde N je množství paměti v bajtech pro uložení hodnoty

V takovém případě jsou rozsahy dostupných celých čísel následující:

• - pro nepodepsané char
• [-128..127] - pro podepsané char

Ve výchozím nastavení je proměnná celočíselného typu považována za podepsanou. Aby bylo v kódu uvedeno, že proměnná má být bez znaménka, je základnímu typu vlevo přiřazen znaménko se znaménkem, tzn. nepodepsaný:

dlouhé hodnoty bez znaménka; // definuje celočíselný (dlouhý) typ bez znaménka.

Uvedené typy se liší pouze velikostí paměti potřebné pro uložení. Protože jazyk C++ je spíše strojový jazykový standard, zaručuje pouze následující podmínku:

• 1 = velikost znaku ≤ krátká velikost ≤ velikost int ≤ dlouhá velikost.

Obvykle jsou velikosti typů následující: char - 1, krátký - 2, int - 4, dlouhý - 8, dlouhý dlouhý - 8 bajtů.

Můžete provádět aritmetické operace s hodnotami typu celé číslo: +, -, *, /, %; srovnávací operace: ==, !=,<=, <, >, >=; bitové operace: &, |, xor,<<, >>.
Většina operací, jako je sčítání, násobení, odčítání a porovnávání, je snadno pochopitelná. Někdy po provedení aritmetických operací může být výsledek mimo rozsah hodnot; v tomto případě program ohlásí chybu.
Celočíselné dělení (/) najde celočíselnou část dělení jednoho celého čísla druhým. Například:

• 6 / 4 = 1;
• 2 / 5 = 0;
• 8 / 2 = 4.

Symbol procenta (%) označuje operaci určení zbytku dělení dvou celých čísel:

• 6 % 4 = 2;
• 10 % 3 = 1.

Obtížněji pochopitelné operace jsou bitově: & (AND), | (OR), xor (exkluzivní OR),<< (побитовый сдвиг влево), >> (bitový posun doprava).

Bitové operace AND, OR a XOR aplikují odpovídající logickou operaci na každý bit informace:

• 1 10 = 01 2
• 3 10 = 11 2
• 1 10 & 3 10 = 01 2 & 11 2 = 01 2
• 1 10 | 3 10 = 01 2 | 11 2 = 11 2
• 1 10 x nebo 3 10 = 01 2 x nebo 11 2 = 10 2

Při zpracování obrazu se pro barvu používají 3 kanály: červený, modrý a zelený - plus průhlednost, které jsou uloženy v proměnné typu int, protože každý kanál má rozsah hodnot od 0 do 255. V hexadecimální soustavě je hodnota zapsána následovně: 0x180013FF; pak hodnota 18 16 odpovídá červenému kanálu, 00 16 - modrý, 13 16 - zelený, FF - alfa kanál (průhlednost). Pro výběr určitého kanálu z takového celého čísla použijte tzv. maska, kde pozice, které nás zajímají, jsou F 16 nebo 1 2 . To znamená, že pro zvýraznění hodnoty modrého kanálu musíte použít masku, tzn. bitově A:

int blue_channel = 0x180013FF & 0x00FF0000;

Poté se přijatá hodnota posune doprava o požadovaný počet bitů.

Bitový posun posune doleva nebo doprava tolik bitů čísla, kolik je uvedeno na pravé straně operace. Například číslo 39 pro typ char v binárním tvaru je zapsáno takto: 00100111. Potom:

Binární znak Příklad = 39; // 00100111 výsledek znaku = binaryExample<< 2; // сдвигаем 2 бита влево, результат: 10011100

Pokud je proměnná typu unsigned, pak výsledkem bude číslo 156, pro proměnnou se znaménkem je rovno -100. Všimněte si, že pro typy celých čísel se znaménkem je jednotka v horním řádu bitové reprezentace znamením, že číslo je záporné. V tomto případě hodnota v binárním tvaru sestávající ze všech jedniček odpovídá -1; pokud je 1 pouze na nejvýznamnější číslici a zbývající číslice jsou nuly, pak má takové číslo minimální hodnotu pro určitý typ hodnoty: pro char je to -128.

2. Typ s pohyblivou řádovou čárkou (float, double (float))

Sada hodnot s plovoucí desetinnou čárkou je podmnožinou reálných čísel, ale ne každé reálné číslo může být reprezentováno binárně, což někdy vede k hloupým chybám:

plovoucí hodnota = 0,2; hodnota == 0,2; // chyba, hodnota zde nebude rovna 0,2.

Při práci s proměnnými s plovoucí desetinnou čárkou by programátor neměl používat operaci rovnosti nebo nerovnosti, místo toho obvykle používá test k dosažení určitého intervalu:

Hodnota - 0,2< 1e-6; // ok, подбирать интервал тоже нужно осторожно

Kromě operací porovnávání podporuje typ s plovoucí desetinnou čárkou 4 aritmetické operace, které jsou plně v souladu s matematickými operacemi s reálnými čísly.

3. Booleovský (logický) typ (bool)

Skládá se pouze ze dvou hodnot: true (true) a false (false). Pro práci s proměnnými tohoto typu se používají logické operace: ! (NE), == (rovnost), != (nerovnost), && (logické AND), || (logické NEBO). Výsledek každé operace lze nalézt v odpovídající pravdivostní tabulce. Například:

4. Typ znaku (char, wchar_t)

Typ char není pouze celočíselný typ (obvykle se takový typ nazývá byte), ale také typ znaku, který ukládá číslo znaku z tabulky jako znak ASCII. Například kód 0x41 odpovídá znaku 'A' a 0x71 - 't'.

Někdy je nutné použít znaky, které nejsou v tabulce ASCII pevně dané, a proto vyžadují uložení více než 1 bajt. Existuje pro ně široký znak (wchar_t).

5.1. Pole

Pole umožňují uložit sekvenční sadu prvků stejného typu. Pole je uloženo v paměti v souvislém bloku, takže pole nelze deklarovat bez určení jeho velikosti. Chcete-li pole deklarovat, za název proměnné napište hranaté závorky () označující její velikost. Například:

int myArray; // Pole 5 prvků typu integer

Pro inicializaci pole jsou hodnoty uvedeny ve složených závorkách. Tímto způsobem můžete inicializovat pouze v době deklarace proměnné. Mimochodem, v tomto případě není nutné specifikovat velikost pole:

int odds = (1, 3, 7, 9, 11); // Pole je inicializováno 5 hodnotami

Chcete-li získat přístup ke konkrétní hodnotě v poli (prvku pole), použijte operaci přístupu k indexu () s číslem prvku (čísla začínají od 0). Například:

šance; // přístup k prvnímu prvku pole. Vrátí hodnotu 1 odds; // přístup ke třetímu prvku. Vrátí hodnotu 7 odds = 13; // Přiřadí novou hodnotu 5. prvku pole odds; // chyba přístupu

5.3. Struny

K zápisu řetězce programátoři používají myšlenku, že řetězec je po sobě jdoucí řada (pole) znaků. K identifikaci konce řádku se používá speciální znak konce řádku: '\0'. Tyto speciální znaky sestávající ze zpětného lomítka a identifikačního znaku se nazývají řídicí nebo únikové znaky. Stále existuje například '\n' - začátek nového řádku, '\t' - tabelování. Pro zaznamenání zpětného lomítka na řádek se používá escapování - před samotný znak se vloží další lomítko: '\'. Escapování se také používá k psaní uvozovek.

Vytvořme řetězcovou proměnnou:

Char textExample = ('T', 'e', ​​​​'s', 't', '\0'); // je zapsán řetězec "Test".

Pro inicializaci řetězce existuje zjednodušený zápis:

Znak textExample = "Test"; // Poslední znak není zapsán, ale velikost je stále 5

Aniž bychom zacházeli do podrobností, zde je další užitečný datový typ - řetězec. Struny
tohoto typu můžete například přidat:

Řetězec hello = "Ahoj,"; stringname = "Max!"; řetězec ahoj_jméno = ahoj + jméno; // Získejte řetězec "Ahoj, Max!"

6. Odkaz

Int a = 2; // proměnná "a" ukazuje na hodnotu 2 int &b = a; // proměnná "b" ukazuje na stejné místo jako "a" b = 4; // změnou hodnoty b změní programátor hodnotu a. Nyní a = 4 int &c = 4; // chyba, nemůžete to udělat, protože referenci nelze přiřadit hodnotu

7. Ukazatel

Pro práci s tímto typem dat je nutné si uvědomit, že množinou hodnot tohoto typu jsou adresy paměťových buněk, odkud data začínají. Ukazatel také podporuje operace sčítání (+), odčítání (-) a dereferencování (*).

Adresy 0x0 znamená, že ukazatel je prázdný, tzn. neukazuje na žádná data. Tato adresa má svůj vlastní literál - NULL:

Int *nullPtr = NULL; // nulový ukazatel

Umožňuje sčítání a odečítání adresy s celým číslem nebo jinou adresou
pohybovat po paměti dostupné programu.

Operace získávání dat začínajících na adrese uložené v ukazateli se nazývá dereferencování (*). Program načte požadovaný počet paměťových buněk a vrátí hodnotu uloženou v paměti.

Int hodnotaInMemory = 2; // nastaví proměnnou celočíselného typu int *somePtr = // zkopíruje adresu proměnné, zde & - vrátí adresu proměnné somePtr; // adresa paměťové buňky, například 0x2F *somePtr; // hodnota je uložena ve 4 buňkách: 0x2F, 0x30, 0x31 a 0x32

U ukazatelů není k dispozici operace přiřazení, která je syntakticky stejná jako operace kopírování. Jinými slovy, můžete zkopírovat adresu jiného ukazatele nebo adresu proměnné, ale nemůžete sami určit hodnotu adresy.

Samotný ukazatel je uložen v paměti, stejně jako hodnoty proměnných jiných typů, a zabírá 4 bajty, takže můžete vytvořit ukazatel na ukazatel.

8. Převody

Výčty jsou jediným základním typem definovaným programátorem. Celkově je výčet uspořádaná sada pojmenovaných celočíselných konstant, přičemž název výčtu je základní typ.

Enumcolor (ČERVENÁ, MODRÁ, ZELENÁ);

Standardně ČERVENÁ = 0, MODRÁ = 1, ZELENÁ = 2. Hodnoty lze tedy vzájemně porovnávat, tzn. ČERVENÉ< BLUE < GREEN. Программист при объявлении перечисления может самостоятельно задать значения каждой из констант:

Enum access(READ=1, WRITE=2, EXEC=4);

Často je vhodné používat výčty, jejichž hodnoty jsou mocninou dvou, protože v binární reprezentaci se číslo, které je mocninou 2, bude skládat z 1. jednotky a nul. Například:

8 10 = 00001000 2

Výsledek sčítání těchto čísel vždy jasně ukazuje, která čísla byla přidána:

37 10 = 00100101 2 = 00000001 2 + 00000100 2 + 00100000 2 = 1 10 + 4 10 + 32 10

Neplatné

Syntakticky je typ void jedním ze základních typů, ale lze jej použít pouze jako součást složitějších typů, protože objekty typu void neexistují. Obvykle se tento typ používá k informování, že funkce nemá návratovou hodnotu, nebo jako základní typ ukazatele na objekty nedefinovaných typů:

prázdný objekt; // chyba, nejsou zde žádné objekty typu void void // chyba, nejsou zde žádné odkazy na void void *ptr; // ok, ulož ukazatel na neznámý typ

Často budeme používat void specificky k označení, že funkce nevrací žádnou hodnotu. Ukazatel typu void se zpracuje, když programátor převezme plnou odpovědnost za integritu paměti a správné přetypování.

Obsazení

Často je nutné přetypovat hodnotu proměnné jednoho typu na jiný. V případě, kdy je množina hodnot původního typu podmnožinou většího typu (například int je podmnožinou long a long je double), může kompilátor implicitně ( implicitně) změnit typ hodnoty.

int celé číslo = 2; plovoucí plovoucí = celé číslo; // plovoucí = 2,0

Typová konverze bude provedena se ztrátou informace, takže z čísla s plovoucí desetinnou čárkou zůstane pouze celočíselná část, zlomková část se ztratí.

Existuje možnost explicitní (explicitní) konverze typu, za tímto účelem vlevo od proměnné nebo nějaké hodnoty původního typu v závorce napište typ, na který bude přetypováno:

hodnota int = (int) 2,5;

Unární a binární operace

Operace, které jsme provedli dříve, se nazývají binární: vlevo a vpravo od symbolu operace jsou hodnoty nebo proměnné, například 2 + 3. Kromě binárních operací používají programovací jazyky také unární operace které se týkají proměnných. Mohou být buď nalevo, nebo napravo od proměnné, několik takových operací se již setkalo - operace dereference (*) a převzetí adresy proměnné (&) jsou unární. Operátory "++" a "-" zvyšují a snižují hodnotu celočíselné proměnné o 1 a mohou být zapsány vlevo nebo vpravo od proměnné.

C++ také používá zkrácený zápis pro binární operace, když levá a pravá strana výrazu obsahují stejnou proměnnou, tzn. nějaká operace se provede s hodnotou proměnné a výsledek operace se uloží do stejné proměnné:

A+= 2; // stejné jako a = a + 2; b/= 5; // stejné jako b = b / 5; c &= 3; // stejné jako c = c & 3;