Posledná aktualizácia: 13.11.2017
Rovnako ako mnoho programovacích jazykov, C # má svoj vlastný systém dátových typov, ktorý sa používa na vytváranie premenných. Typ údajov definuje internú reprezentáciu údajov, množinu hodnôt, ktoré môže objekt prijať, a platné akcie, ktoré možno na objekt použiť.
Jazyk C # má nasledujúce primitívne dátové typy:
bool: platí true alebo false (booleovské literály). Reprezentovaný typom systému System.Boolean
Bool nažive = pravda; bool isDead = false;
byte: ukladá celé číslo od 0 do 255 a zaberá 1 bajt. Reprezentovaný typom systému System.Byte
Bajt bit1 = 1; byte bit2 = 102;
sbyte: ukladá celé číslo od -128 do 127 a zaberá 1 bajt. Reprezentovaný typom systému System.SByte
Sbyte bit1 = -101; sbyte bit2 = 102;
krátky: uloží celé číslo od -32768 do 32767 a zaberie 2 bajty. Reprezentovaný typom systému System.Int16
Krátke n1 = 1; krátke n2 = 102;
ushort: ukladá celé číslo od 0 do 65535 a zaberá 2 bajty. Reprezentovaný typom systému System.UInt16
Ushort n1 = 1; skratka n2 = 102;
int: ukladá celé číslo od -2147483648 do 2147483647 a zaberá 4 bajty. Reprezentovaný typom systému System.Int32. Všetky celočíselné literály štandardne predstavujú hodnoty typu int:
Int a = 10; int b = 0b101; // binárna forma b = 5 int c = 0xFF; // hexadecimálny tvar c = 255
uint: ukladá celé číslo od 0 do 4294967295 a zaberá 4 bajty. Reprezentovaný typom systému System.UInt32
Uint a = 10; uint b = 0b101; uint c = 0xFF;
long: ukladá celé číslo od –9 223 372 036 854 775 808 do 9 223 372 036 854 775 807 a zaberá 8 bajtov. Reprezentovaný typom systému System.Int64
dlhé a = -10; dlhé b = 0b101; dlhé c = 0xFF;
ulong: ukladá celé číslo od 0 do 18 446 744 073 709 551 615 a zaberá 8 bajtov. Reprezentovaný typom systému System.UInt64
Ulong a = 10; ulong b = 0b101; ulong c = 0xFF;
float: ukladá číslo s pohyblivou rádovou čiarkou od -3,4 * 10 38 do 3,4 * 10 38 a zaberie 4 bajty. Zastúpený typom systému System.Single
double: ukladá číslo s pohyblivou rádovou čiarkou od ± 5,0 * 10 -324 do ± 1,7 * 10 308 a zaberá 8 bajtov. Zastúpený typom systému System.Double
desiatkový: ukladá desatinné zlomkové číslo. Ak sa používa bez desatinnej čiarky, má hodnotu od ± 1,0 * 10 -28 do ± 7,9228 * 10 28, môže uložiť 28 desatinných miest a zaberá 16 bajtov. Reprezentovaný typom systému System.Decimal
char: ukladá jeden znak Unicode a zaberá 2 bajty. Zastúpený typom systému System.Char. Znakové literály zodpovedajú tomuto typu:
Char a = "A"; char b = "\ x5A"; char c = "\ u0420";
string: ukladá znakovú sadu Unicode. Reprezentovaný typom systému System.String. Tomuto typu zodpovedajú znakové literály.
Reťazec ahoj = "Ahoj"; reťazec slovo = "svet";
objekt: môže uložiť hodnotu akéhokoľvek typu údajov a má veľkosť 4 bajty na 32-bitovej platforme a 8 bajtov na 64-bitovej platforme. Predstavuje ho systémový typ System.Object, ktorý je základným typom pre všetky ostatné typy a triedy .NET.
Objekt a = 22; objekt b = 3,14; objekt c = "ahoj kód";
Napríklad definujme niekoľko premenných rôznych typov a vytlačte ich hodnoty do konzoly:
Používanie systému; menný priestor HelloApp (trieda Program (statický void Main (argumenty reťazca) (meno reťazca = "Tom"; int vek = 33; bool isEmployed = false; dvojitá váha = 78,65; Console.WriteLine ($ "Name: (meno)"); Console.WriteLine ($ "Vek: (vek)"); Console.WriteLine ($ "Hmotnosť: (hmotnosť)"); Console.WriteLine ($ "Works: (isEmployed)");)))
Na výstup údajov do konzoly sa tu používa interpolácia: znak $ sa umiestni pred reťazec a potom môžeme zadať hodnoty premenných v reťazci v zložených zátvorkách. Výstup programu na konzolu:
Meno: Tom Vek: 33 Váha: 78,65 Spracované: Falošné
Používanie prípon
Pri priraďovaní hodnôt majte na pamäti nasledujúcu jemnosť: všetky skutočné literály sa považujú za dvojité hodnoty. A aby ste označili, že zlomkové číslo predstavuje plávajúci alebo desiatkový typ, musíte k doslovu pridať príponu: F / f pre plávajúce číslo a M / m pre desatinné číslo.
Podobne všetky celočíselné literály sa považujú za hodnoty typu int. Ak chcete explicitne uviesť, že celočíselný literál predstavuje hodnotu uint, musíte použiť príponu U / u, long s príponou L / l a ulong s príponou UL / ul:
Uint a = 10U; dlhé b = 20L; ulong c = 30 UL;
Použitie typov systémov
Vyššie, pri uvádzaní všetkých základných dátových typov, bol pri každom uvedený typ systému. Pretože názov vstavaného typu je v podstate skratka pre typ systému. Napríklad nasledujúce premenné budú ekvivalentné v type:
Int a = 4; System.Int32 b = 4;
Implicitné písanie
Predtým sme explicitne špecifikovali typ premenných, napríklad int x; ... A kompilátor už pri spustení vedel, že x ukladá celočíselné hodnoty.
Môžeme však použiť aj model implicitného typovania:
Var ahoj = "Do pekla svetu"; var c = 20; Console.WriteLine (c.GetType (). ToString ()); Console.WriteLine (hello.GetType (). ToString ());
Pri implicitnom písaní sa namiesto názvu typu údajov používa kľúčové slovo var. Potom počas kompilácie kompilátor sám odvodí typ údajov na základe priradenej hodnoty. Vyššie uvedený príklad použil výraz Console.WriteLine (c.GetType (). ToString ()); čo nám umožňuje zistiť odvodený typ premennej c. Keďže štandardne sa všetky celočíselné hodnoty považujú za typu int, tak nakoniec premenná c bude typu int alebo System.Int32
Tieto premenné sú podobné normálnym premenným, ale majú určité obmedzenia.
Po prvé, nemôžeme najprv deklarovať implicitne napísanú premennú a potom inicializovať:
// tento kód funguje int a; a = 20; // tento kód nefunguje var c; c = 20;
Po druhé, nemôžeme zadať hodnotu null ako hodnotu implicitne napísanej premennej:
// tento kód nefunguje var c = null;
Keďže je hodnota null, kompilátor nemôže odvodiť typ údajov.
dvojité alebo desatinné
Z uvedeného zoznamu dátových typov je zrejmé, že ak chceme v programe použiť čísla do 256, tak na ich uloženie môžeme použiť premenné typu byte. Pri použití veľkých hodnôt môžeme použiť typy short, int, long. To isté platí pre zlomkové čísla - pre bežné zlomkové čísla môžete použiť typ float, pre veľmi veľké zlomkové čísla - dvojitý typ. Desatinný typ tu vyniká v tom zmysle, že napriek veľkej bitovej hĺbke v porovnaní s typom double môže typ double uložiť väčšiu hodnotu. Desatinná hodnota však môže obsahovať až 28 desatinných miest, kým dvojnásobná hodnota môže mať 15 až 16 desatinných miest.
Desatinné číslo sa častejšie používa vo finančných výpočtoch, zatiaľ čo dvojnásobok sa používa v matematických operáciách. Všeobecné rozdiely medzi týmito dvoma typmi možno zhrnúť v nasledujúcej tabuľke.
odpoveď:
- Typy celočíselných údajov:
short int, unsigned short int, int, unsigned int, long, unsigned long.
- Typy údajov s pohyblivou rádovou čiarkou (zodpovedajú skutočným typom):
plavák, dvojitý, dlhý dvojitý.
- Typ údajov znaku:
char (signed char), unsigned char, wchar_t.
- Booleovský typ údajov:
bool.
- Vyčíslený typ údajov (zavedený vo Visual C ++):
enum.
2. Aké sú vlastnosti používania celočíselných dátových typov?
V C ++ sú základné celočíselné dátové typy: short int, unsigned short int, int, unsigned int, long (long int), unsigned long (unsigned long int).
Tieto typy údajov predstavujú hodnoty z rôznych celých čísel. Napríklad:
2 -100 398Typy údajov, ktoré začínajú predponou bez znamienka, môžu obsahovať iba kladné čísla.
Údaje typu short int, unsigned short int zaberajú dvakrát menej miesta v pamäti ako údaje typu int, unsigned int.
Údaje typu long, unsigned long zaberajú dvakrát viac miesta v pamäti ako údaje typu int, unsigned int.
3. Ako opísať premennú s názvom x celočíselného typu v programe?
odpoveď:
int x; // celé číslo so znamienkomV dôsledku toho pod premennou X bude pridelený pamäťový priestor 4 bajty. Veľkosť pamäte, ktorá je pre premennú pridelená, závisí od vlastností počítača, typu operačného systému a nastavení kompilátora.
4. Ako zapísať číslo 239 do premennej celočíselného typu?
Na to použite operátor priradenia, ktorý je označený symbolom '='.
odpoveď 1. Zadanie čísla do premennej po jej popise.
int x; x = 239;odpoveď 2. Zadanie čísla do premennej pri jej deklarácii (počiatočná inicializácia).
int x = 239;5. Aké sú vlastnosti dátových typov s pohyblivou rádovou čiarkou?
Dátové typy s pohyblivou rádovou čiarkou môžu reprezentovať hodnoty z množiny reálnych čísel. Napríklad:
8.35 -990.399 239.0.C ++ má tieto základné typy údajov s pohyblivou rádovou čiarkou: float, double, long double.
Dvojitá premenná zaberá 2-krát viac miesta v pamäti počítača ako float premenná.
Taktiež premenná typu long double zaberá 2-krát viac miesta v pamäti počítača ako premenná typu double.
6. Ako opísať premennú, ktorá nadobúda hodnotu s pohyblivou rádovou čiarkou?
Príklad popisu premenných typu float, double, long double:
plavák f; dvojité d; dlhý dvojitý ld;7. Ako zapísať číselné hodnoty do premennej s pohyblivou rádovou čiarkou?
Príklad zadávania číselných údajov do typov premenných s pohyblivou rádovou čiarkou:
float f = -9928,45; // úvodná inicializácia dvojité d; dlhý dvojitý ld; d = 0,445332; // operátor priradenia ld = 3892923898239,030903; // operátor priradenia8. Ako previesť premennú typu float na typ int?
Na to sa používa operácia typového odlievania. V zátvorkách je potrebné uviesť názov typu, na ktorý sa konverzia uskutočňuje.
plavák a; int b; a = 8,457; b = (int) a; // b = 8Pri používaní operácií pretypovania musíte brať do úvahy obmedzenia, ktoré platia pre typy, ktoré zaberajú menej miesta v pamäti počítača.
Napríklad premenná typu short int môže predstavovať menší rozsah čísel ako premenné typu float, double. V nasledujúcom zozname dochádza k pretečeniu hodnoty v premennej typu short int:
krátke int i; plavák f; f = 3990099,8; i = (int) f; // i = -7597 - pretečenie9. Ako previesť premennú z typu int na typ double?
Príklad pretypovania z int na double:
int i; dvojité d; i = 982; d = (dvojitý) i; // d = 982,010. Aké sú vlastnosti používania údajov o znakoch (údaje o znakoch) v programe?
Údaje char predstavujú hodnotu znaku kódu zadaného z klávesnice. Kód znaku je celé číslo.
Napríklad kód znaku pre „f“ je 102.
Útržok kódu, v ktorom sa vypočíta kód znaku:
int kód; znak znaku; symbol = "f"; kód = (int) symbol; // kód = 102Údaje znakov sú rovnaké celé čísla. Údaje znaku zaberajú 1 bajt v pamäti počítača.
Vzťah medzi znakmi a kódom sa nachádza v tabuľke znakov systému Windows. Znaky s kódmi 0 až 127 sú znaky vyhradené systémom BIOS. Zahŕňajú najčastejšie používané symboly, číselné symboly, symboly latinskej abecedy. Tieto symboly nie je možné zmeniť.
Znaky s kódmi od 128 do 255 sú regionálne znaky, ktoré sú viazané na konkrétnu abecedu počítača, na ktorom je nainštalovaný operačný systém Windows.
11. Aké sú vlastnosti používania údajov typu bool (logický typ)?
Premenné typu bool môžu nadobúdať iba dve hodnoty:
pravda,
nepravda je nepravda.
Tieto premenné sa používajú na testovanie boolovských výrazov. Číselná hodnota true je 1. Číselná hodnota false je 0.
Útržok kódu, ktorý definuje číselné hodnoty true a false:
int výsledok; bool b; vysledok = (int) true; // výsledok = 1 b = nepravda; výsledok = (int) b; // výsledok = 0Útržok kódu, ktorý prevádza typy int a float na bool:
int i; plavák f; bool b; i = 6; b = (bool) i; // b = Pravda f = 0,0; b = (bool) f; // b = False12. Ako určiť veľkosť pamäte obsadenej premennou daného typu?
Používa sa na to operácia sizeof ().
Útržok kódu, ktorý určuje veľkosť niektorých typov údajov:
int d; d = veľkosť (char); // d = 1 d = sizeof (unsigned int); // d = 4 d = veľkosť (float); // d = 4 d = veľkosť (dvojnásobok); // d = 813. Ako sa inicializujú premenné rôznych typov?
int d = 28; float z = (float) 2,85; char c = "k"; Reťazec ^ s = "Ahoj!" ; dvojité r = -8,559;14. Ako určiť maximálnu prípustnú (minimálne prípustnú) hodnotu premennej určitého typu?
.NET Framework používa vlastnosti MaxValue a MinValue na určenie maximálnej alebo minimálnej prijateľnej hodnoty pre premennú určitého typu.
Príklady stanovenia limitných hodnôt premenných rôznych typov.
Pre premenné typu int:
// typ int int i; dlhý MaxInt; dlhá MinInt; MaxInt = (dlhá) i.MaxValue; // MaxInt = 2147483647 MinInt = (dlhá) i.MinValue; // MinInt = -2147483648Pre premenné typu short int:
// krátky typ int krátke int si; int MaxInt; int MinInt; MaxInt = (int) si.MaxValue; // MaxInt = 32767 MinInt = (int) si.MinValue; // MinInt = -32768Pre premenné typu unsigned int:
// neprihlásený typ int unsigned int ui; unsigned int MaxInt; unsigned int MinInt; MaxInt = ui.MaxValue; // MaxInt = 4294967295 MinInt = ui.MinValue; // MinInt = 0Pre plávajúce premenné:
// typ float plavák f; plavák MaxF; plavák MinF; MaxF = f.MaxValue; // MaxF = 3,402823E + 38 MinF = f.MinValue; // MinF = -3,402823E + 38Pre premenné typu double:
// dvojitý typ dvojité d; dvojité MaxD; dvojitá MinD; Max = d.MaxValue; // Max = 1,79769313486232E + 308 Min = d.MinValue; // Min = -1,79769313486232E + 308Pre premenné typu char:
// typ znaku char c; int MaxC; int MinC; Max = (int) c.MaxValue; // Max = 127 Min = (int) c.MinValue; // Min = -12815. Aké sú vlastnosti používania typu enum?
Enum typ je enumerovaný dátový typ. Špecifikuje mnemotechnické hodnoty pre množiny celočíselných hodnôt. Každý mnemotechnický význam má špecifický obsah a je reprezentovaný celým číslom.
Príklad použitia typu enum na vyjadrenie mesiacov v roku:
výpočtové mesiace (január, február, marec, apríl, máj, jún, júl, august, september, október, november, december) mn; mn = január; // mn = 0 mn = marec; // mn = 2 mn = september; // mn = 8Uvedený príklad popisuje premennú s názvom mn typu enum months. Mnemotechnické hodnoty pre mesiace (január, február,…) začínajú na 0 (0, 1, 2,…). Mnemotechnická pomôcka Január je celé číslo 0, mnemotechnická pomôcka Február je celé číslo 1 atď.
Takže pomocou typu enum môžete použiť mnemotechnické zápisy v texte programu pre lepšiu prehľadnosť zdrojového kódu.
Môžete napísať aj toto:
mn = (počet mesiacov) 2; // mn = marec mn = (výpočet mesiacov) 11; // mn = december16. Aké sú vlastnosti aplikácie daného typuneplatné v programoch preC++ ?
Typ údajov void sa používa v nasledujúcich prípadoch:
- ak potrebujete opísať funkciu, ktorá nevracia žiadnu hodnotu (pozri príklad);
- ak potrebujete opísať funkciu, ktorá neprijíma parametre (pozri príklad).
Príklad... Funkcia MyFun () bez parametrov, ktorá nevracia žiadnu hodnotu (vracia typ void) a neprijíma parametre.
verejné: void MyFun (neplatné) { // telo funkcie // ... návrat; // návrat z funkcie, ktorá nevracia hodnotu } // volanie funkcie z programu ... MyFun (); ...17. Je možné deklarovať premennú typu?neplatné v programe?
Je to nemožné, pretože typ void nie je spojený s hodnotou.
Deklarovanie premennej typu void vedie k chybe kompilácie s výstupom správy:
"Nezákonné použitie typu void"18. Aké sú vlastnosti aplikácie daného typuwchar_ t vVizuálne C++ ?
Premenné typu char (pozri predchádzajúce body) slúžia na ukladanie 8-bitových ASCII znakov.
Typ wchar_t sa používa na ukladanie znakov, ktoré sú súčasťou veľkých znakových sád. Napríklad čínska abeceda má obrovské množstvo znakov. 8 bitov nestačí na reprezentáciu celej znakovej sady čínskej abecedy. Preto, ak potrebujete použiť program na medzinárodnom trhu, je vhodné nahradiť typ char wchar_t.
Príklad pomocou typu wchar_t.
... wchar_t t; // Pre premennú t sú alokované 2 bajty pamäte t = "s"; ...V jazyku C sa rozlišujú pojmy „údajový typ“ a „modifikátor typu“. Typ údajov je celé číslo a modifikátor je so znamienkom alebo bez znamienka. Celé číslo so znamienkom bude mať kladné aj záporné hodnoty a celé číslo bez znamienka bude mať iba kladné hodnoty. V jazyku C existuje päť základných typov.
- char je charakter.
- int je celé číslo.
- plavák je skutočný.
- double - double precision real;
- prázdnota je irelevantná.
Premenná typu char má veľkosť 1 bajt, jej hodnoty sú rôzne znaky z kódovej tabuľky, napríklad: '', ':', 'j' (keď sú napísané v programe, sú uzavreté v jednotke citácie).
Veľkosť premennej typu int nie je v štandarde C definovaná. Vo väčšine programovacích systémov veľkosť premennej typu int zodpovedá veľkosti celého strojového slova. Napríklad v kompilátoroch pre 16-bitové procesory má premenná int veľkosť 2 bajty. V tomto prípade sa hodnoty so znamienkom tejto premennej môžu pohybovať od -32768 do 32767.
Kľúčové slovo float vám umožňuje definovať premenné skutočného typu. Ich hodnoty majú zlomkovú časť oddelenú bodkou, napríklad: -5,6, 31,28 atď. Reálne čísla možno zapísať aj vo forme s pohyblivou rádovou čiarkou, napríklad: -1,09e + 4. Číslo pred "e" sa nazýva mantisa a po "e" - poradie. Premenná float zaberá 32 bitov v pamäti. Môže nadobudnúť hodnoty v rozsahu od 3,4e-38 do 3,4e + 38.
Kľúčové slovo double vám umožňuje definovať skutočnú premennú s dvojitou presnosťou. Zaberá dvakrát toľko miesta v pamäti ako float premenná. Premenná dvojitého typu môže nadobúdať hodnoty v rozsahu od 1,7e-308 do 1,7e + 308.
Kľúčové slovo void sa používa na neutralizáciu hodnoty objektu, napríklad na deklarovanie funkcie, ktorá nevracia žiadne hodnoty.
Variabilné typy:
Programy pracujú s rôznymi údajmi, ktoré môžu byť jednoduché a štruktúrované. Jednoduché dáta sú celé čísla a reálne čísla, symboly a ukazovatele (adresy objektov v pamäti). Celé čísla nemajú a reálne čísla majú zlomkovú časť. Štruktúrované dáta sú polia a štruktúry; budú diskutované nižšie.
Premenná je miesto v pamäti počítača, ktoré má názov a uchováva nejakú hodnotu. Hodnota premennej sa môže počas vykonávania programu meniť. Pri zápise novej hodnoty do bunky sa stará vymaže.
Dobrým štýlom je zmysluplne pomenovať premenné. Názov premennej môže obsahovať jeden až 32 znakov. Je povolené používať malé a veľké písmená, čísla a znak podčiarknutia, ktorý sa v C považuje za písmeno. Prvý znak musí byť písmeno. Názov premennej nemôže byť rovnaký ako vyhradené slová.
Typ znaku
char je najhospodárnejší typ. Typ znaku môže byť podpísaný alebo nepodpísaný. Označuje sa ako „signed char“ (podpísaný typ) a „unsigned char“ (nepodpísaný typ). Podpísaný typ môže ukladať hodnoty v rozsahu -128 až +127. Bez znamienka - od 0 do 255. Premennej typu char je pridelený 1 bajt pamäte (8 bitov).
Kľúčové slová so znamienkom a bez znamienka označujú, ako sa interpretuje nulový bit deklarovanej premennej, t.j. ak je špecifikované kľúčové slovo bez znamienka, potom sa nulový bit interpretuje ako časť čísla, v opačnom prípade sa nulový bit interpretuje ako so znamienkom.
Typ Int
Celočíselná hodnota int môže byť krátka alebo dlhá. Krátke kľúčové slovo sa umiestni za podpísané alebo nepodpísané kľúčové slová. Existujú teda typy: podpísané short int, unsigned short int, signed long int, unsigned long int.
Premenná typu signované krátke int (krátke celé číslo so znamienkom) môže nadobúdať hodnoty od -32768 do +32767, krátke int bez znamienka (krátke celé číslo bez znamienka) - od 0 do 65535. Presne dva bajty pamäte (16 bitov) sú alokované pre každý z nich.
Pri deklarovaní premennej typu sign short int je možné kľúčové slová sign a short vynechať a takúto premennú je možné deklarovať ako jednoducho int. Je tiež povolené deklarovať tento typ jedným krátkym kľúčovým slovom.
Premennú unsigned short int možno deklarovať ako unsigned int alebo unsigned short.
Pre každú hodnotu long int so znamienkom alebo bez znamienka sú alokované 4 bajty pamäte (32 bitov). Hodnoty premenných tohto typu sa môžu pohybovať od -2147483648 do 2147483647 a od 0 do 4294967295.
Existujú aj premenné typu long long int, pre ktoré je alokovaných 8 bajtov pamäte (64 bitov). Môžu byť podpísané alebo nepodpísané. Pre typ so znamienkom leží rozsah hodnôt v rozsahu od -9223372036854775808 do 9223372036854775807, pre typ bez znamienka - od 0 do 18446744073709551615. S dvoma dlhými kľúčovými slovami typu long možno deklarovať jednoducho.
| Typ | Rozsah | Hexadecimálny rozsah | Veľkosť |
| nepodpísaný char | 0 … 255 | 0x00 ... 0xFF | 8 bit |
| podpísaný char alebo jednoducho char |
-128 … 127 | -0x80 ... 0x7F | 8 bit |
| unsigned short int alebo jednoducho unsigned int alebo unsigned short |
0 … 65535 | 0x0000 ... 0xFFFF | 16 bit |
| podpísané krátke int alebo podpísané int alebo jednoducho krátky alebo int |
-32768 … 32767 | 0x8000 ... 0x7FFF | 16 bit |
| unsigned long int alebo jednoducho nepodpísané dlhé |
0 … 4294967295 | 0x00000000 ... 0xFFFFFFFF | 32 bit |
| podpísaný dlho alebo jednoducho dlhý |
-2147483648 … 2147483647 | 0x80000000 ... 0x7FFFFFFF | 32 bit |
| nepodpísané dlhé dlhé | 0 … 18446744073709551615 | 0x0000000000000000 ... 0xFFFFFFFFFFFFFFFF | 64 bit |
| podpísaný dlho dlho alebo jednoducho dlho dlho |
-9223372036854775808 … 9223372036854775807 | 0x8000000000000000 ... 0x7FFFFFFFFFFFFFFFF | 64 bit |
Deklarovanie premenných
Premenné sú deklarované v deklaračnom príkaze. Deklaračný príkaz pozostáva zo špecifikácie typu a zo zoznamu názvov premenných oddelených čiarkami. Na konci musí byť bodkočiarka.
[modifikátory] typ_kvalifikátor id [, id] ...
Modifikátory - kľúčové slová podpísané, nepodpísané, krátke, dlhé.
Špecifikátor typu je kľúčové slovo char alebo int, ktoré definuje typ deklarovanej premennej.
Identifikátor je názov premennej.
znak x; int a, b, c; bez znamienka dlhé dlhé y;
Pri deklarovaní premennej môžete inicializovať, teda priradiť jej počiatočnú hodnotu.
Int x = 100;
Pri deklarácii sa do premennej x okamžite zapíše číslo 100. Inicializované premenné je lepšie deklarovať v samostatných riadkoch.
V tomto návode sa to naučíte Abeceda C++ a tiež čo dátové typy môže byť spracovaný programom na ňom. Možno to nie je najvzrušujúcejší moment, ale tieto znalosti sú potrebné! Navyše, keď sa začnete učiť akýkoľvek iný programovací jazyk, budete sebavedomejšie prechádzať podobnou fázou učenia. Program C++ môže obsahovať nasledujúce znaky:
- veľké, malé latinské písmená A, B, C…, x, y, z a podčiarkovník;
- arabské číslice od 0 do 9;
- špeciálne znaky: (), | , () + - / % *. \':?< > = ! & # ~ ; ^
- znaky medzery, tabulátora a nového riadku.
V teste programu môžete použiť komentáre... Ak text s dvoma lomkami // a končí znakom nového riadku alebo je uzavretý medzi / * a * /, kompilátor ho ignoruje.
Údaje v C++
Na vyriešenie problému v akomkoľvek programe sa spracujú akékoľvek údaje. Môžu byť rôznych typov: celé čísla a reálne čísla, symboly, reťazce, polia. Je zvykom popísať dáta v C++ na začiatku funkcie. TO základné dátové typy jazyk patrí:
Pre tvorbu ďalších typov údajov, základných a tzv špecifikátory. C ++ definuje štyri špecifikátory typu údajov:
- krátky - krátky;
- dlhý - dlhý;
- podpísaný - podpísaný;
- nepodpísaný — nepodpísaný.
Typ celého čísla
Premenná typu int v pamäti počítača môže trvať 2 alebo 4 bajty. Závisí to od bitovej kapacity procesora. Štandardne sa všetky typy celých čísel považujú za podpísané, teda špecifikátor podpísaný možno vynechať. Špecifikátor nepodpísané umožňuje reprezentovať iba kladné čísla. Nižšie sú uvedené niektoré rozsahy celočíselných hodnôt
| Typ | Rozsah | Veľkosť |
| int | -2147483648…2147483647 | 4 bajty |
| unsigned int | 0…4294967295 | 4 bajty |
| podpísané int | -2147483648…2147483647 | 4 bajty |
| krátky int | -32768…32767 | 2 bajty |
| dlhá int | -2147483648…2147483647 | 4 bajty |
| unsigned short int | 0…65535 | 2 bajty |
Skutočný typ
Číslo s pohyblivou rádovou čiarkou je znázornené v tvare mE + - p, kde m je mantisa (celé číslo alebo zlomkové číslo s desatinnou čiarkou), p je poradie (celé číslo). Zvyčajne hodnoty ako plavák zaberajú 4 bajty a dvojitý 8 bajtov. Tabuľka skutočného rozsahu:
| plavák | 3,4E-38 ... 3,4E + 38 | 4 bajty |
| dvojitý | 1,7E-308 ... 1,7E + 308 | 8 bajtov |
| dlhý dvojitý | 3,4E-4932 ... 3,4E + 4932 | 8 bajtov |
Booleovský typ
Premenná typu bool môže nadobudnúť iba dve hodnoty pravda ( pravda ) alebo fasle ( Klamstvo ). Akákoľvek hodnota iná ako nula sa interpretuje ako pravda. Význam falošné reprezentovaný v pamäti ako 0.
Prázdny typ
Mnohé hodnoty tohto typu sú prázdne. Používa sa na definovanie funkcií, ktoré nevracajú hodnotu, na určenie prázdneho zoznamu argumentov funkcií, ako základný typ pre ukazovatele a pri operáciách pretypovania.
Konverzia typu údajov
C++ rozlišuje dva typy konverzie dátových typov: explicitnú a implicitnú.
- Implicitná konverzia deje automaticky. Deje sa tak pri porovnávaní, priraďovaní alebo vyhodnocovaní výrazov rôznych typov. Napríklad nasledujúci program vytlačí do konzoly hodnotu ako plavák.
#include "stdafx.h" #include
#include "stdafx.h" #include pomocou menného priestoru std; int main () int i = 5; float f = 10,12; cout<< i / f ; systém ("pauza >> void"); návrat 0; |
Najvyššiu prioritu má typ s najmenšou stratou informácií. Nemali by ste zneužívať implicitnú konverziu typov, pretože môžu nastať najrôznejšie neočakávané situácie.
- Explicitná konverzia na rozdiel od implicitne vykonávaného programátorom. Existuje niekoľko spôsobov, ako to urobiť:
- Konverzia na štýly C: (plávajúci) a
- Konverzia na štýly C++: plavák ()
Konverzie typov je možné vykonávať aj pomocou nasledujúcich operácií:
static_cast<>() const_cast<>() reinterpret_cast<>() dynamic_cast<> ()
static_cast<> () const_cast<> () reinterpret_cast<> () dynamic_cast<> () |
static_cas- vykonáva konverziu súvisiacich dátových typov. Tento operátor prenáša typy podľa zvyčajných pravidiel, ktoré sa môžu vyžadovať, keď kompilátor nevykonáva automatickú konverziu. Syntax bude vyzerať takto:
Typ statického_castu<Тип>(objekt);
Pomocou static_cast nemôžete odstrániť konštantnosť z premennej, ale je to v rámci sily nasledujúceho príkazu. const_cast- používa sa len vtedy, keď je potrebné z objektu odstrániť konštanty. Syntax bude vyzerať takto:
Typconst_cast< Typ> (objekt);
reinterpret_cast- slúži na prevod rôznych typov, celých čísel na ukazovateľ a naopak. Ak uvidíte nové slovo "ukazovateľ" - neznepokojujte sa! je to tiež dátový typ, ale čoskoro s ním nebudeme pracovať. Syntax je tu rovnaká ako pre predtým uvažované operátory:
Typreinterpretovať_cast< Typ> (objekt);
dynamic_cast- používa sa na dynamickú konverziu typu, implementuje pretypovanie ukazovateľov alebo odkazov. Syntax:
Typdynamický _cast< Typ> (objekt);
Riadiace znaky
Niektoré z týchto „riadiacich znakov“ už poznáte (napr \ n). Všetky začínajú opačnou lomkou a sú tiež obklopené dvojitými úvodzovkami.
|
Obrázok |
Hexadecimálny kód |
názov |
|
Zvuk pípača |
||
|
Backtrack |
||
|
Preklad stránky (formát) |
||
|
Preklad riadkov |
||
|
Vrátenie vozíka |
||
|
Vodorovná karta |
||
|
Vertikálna karta |
||
Všetky údaje v jazyku C majú svoj vlastný typ. Premenné určitých typov zaberajú určité miesto v pamäti, ktoré sa líši v závislosti od typu. V C nie je jasné priradenie množstva pamäte k určitým typom. Toto je dané implementáciou špecifického kompilátora pre konkrétnu platformu. Napríklad premenná ako int v jednom kompilátore môže zaberať 16 bitov v pamäti, v inom - 32 bitov, v treťom - 8 bitov. Všetko určuje konkrétny kompilátor. Je pravda, že každý sa snaží o univerzalizáciu a v podstate vo väčšine kompilátorov typ int , napríklad zaberá 2 bajty a typ char - jeden.
V poslednej dobe som bol trochu nudný, nevedel som si spomenúť, koľko bajtov typ zaberá dvojitý v AVR-GCC... Väčšinou sa pri programovaní regulátorov pracuje s celočíselnými typmi, ako napr int a char a často sa neuchyľujete k typom s pohyblivou rádovou čiarkou kvôli ich spotrebe zdrojov.
Preto si tu do budúcnosti nechám pre seba poznámku označujúcu veľkosť pamäte obsadenej dátovými typmi pre kompilátor AVR-GCC a rozsah zmeny premenných tohto typu.
Dátové typy C pre kompilátor AVR-GCC
| Typ | Veľkosť v bajty (bity) |
Interval výmeny |
|---|---|---|
| char | 1 (8) | -128 .. 127 |
| nepodpísaný char | 1 (8) | 0 .. 255 |
| podpísaný char | 1 (8) | -128 .. 127 |
| int | 2 (16) | -32768 .. 32767 |
| unsigned int | 2 (16) | 0 .. 65535 |
| podpísané int | 2 (16) | -32768 .. 32767 |
| krátky int | 2 (16) | -32768 .. 32767 |
| unsigned short int | 2 (16) | 0 .. 65535 |
| podpísané krátke int | 2 (16) | -32768 .. 32767 |
| dlhá int | 4 (32) | -2147483648 .. 2147483647 |
| unsigned long int | 4 (32) | 0 .. 4294967295 |
| podpísané dlhé int | 4 (32) | -2147483648 .. 2147483647 |
| plavák | 4 (32) | 3,4E-38 .. 3,4E + 38 |
| dvojitý | 4 (32) | 3,4E-38 .. 3,4E + 38 |
| dlhý dvojitý | 10 (80) | 3,4 Е-4932 .. 3,4 Е + 4932 |
Implementácia typu dvojitý AVR-GCC sa odchyľuje od štandardu. Štandardné dvojitý trvá 64 bitov. V AVR-GCC premenná tohto typu zaberá 32 bitov, a preto je ekvivalentná premennej s typom plavák!
Okrem toho knižnice AVR-GCC zaviedli niekoľko derivátov štandardných typov. Sú popísané v súbore stdint.h ... Bolo to urobené pravdepodobne kvôli zlepšeniu prehľadnosti a zmenšeniu textu programov (zrýchlenie ich písania :)). Tu je tabuľka súladu:
Typy odvodené od štandardných typov v jazyku C pre kompilátor AVR-GCC
| Odvodený typ | Štandardný typ |
|---|---|
| int8_t | podpísaný char |
| uint8_t | nepodpísaný char |
| int16_t | podpísané int |
| uint16_t | unsigned int |
| int32_t | podpísané dlhé int |
| uint32_t | unsigned long int |
| int64_t | podpísané dlhé dlhé vt |
| uint64_t | unsigned long long int |
Prázdny typ
V jazyku C existuje ešte jeden typ – typ neplatné . Void sa používa na označenie toho, že funkcia vo výsledku nič nevracia alebo neberie ako vstup žiadne parametre. Tento typ sa nepoužíva na deklarovanie premenných, takže nezaberá miesto v pamäti.