Kõrgeim prioriteet on tüübil, mille puhul läheb kõige vähem teavet kaduma. Te ei tohiks kuritarvitada kaudset tüübi teisendamist, kuna võib tekkida mitmesuguseid ettenägematuid olukordi.

• Selgesõnaline teisendamine erinevalt kaudsest viib selle läbi programmeerija. Selle teisenduse tegemiseks on mitu võimalust:

1. Stiilideks teisendamine C: (ujuk) a
2. Stiilideks teisendamine C++: float ()

Tüübivalu saab teostada ka järgmiste toimingute abil:

static_cast<>()const_cast<>() reinterpret_cast<>() dynamic_cast<> ()

static_cas- teisendab seotud andmetüüpe. See operaator heidab tüüpe tavaliste reeglite järgi, mis võib olla vajalik, kui kompilaator ei teosta automaatset teisendamist. Süntaks näeb välja selline:

Tippige static_cast<Тип>(objekt);

Kasutades static_cast, ei saa te muutujast püsivust eemaldada, kuid järgmine operaator saab seda teha. const_cast- kasutatakse ainult siis, kui on vaja eemaldada objektilt püsivus. Süntaks näeb välja selline:

Tüüpconst_cast< Tüüp> (objekt);

reinterpret_cast- kasutatakse erinevate tüüpide, täisarvude teisendamiseks osutiks ja vastupidi. Kui näete uut sõna "indeks" - ärge kartke! See on samuti andmetüüp, kuid me ei tööta sellega niipea. Siin on süntaks sama, mis eelnevalt käsitletud operaatoritel:

Tüüpümber tõlgendada_cast< Tüüp> (objekt);

dynamic_cast- kasutatakse dünaamilise tüübi teisendamiseks, rakendab osuti või võrdlusvalu. Süntaks:

Tüüpdünaamiline _cast< Tüüp> (objekt);

Juhtmärgid

Mõned neist "juhtmärkidest" on teile juba tuttavad (näiteks \n). Kõik need algavad kaldkriipsuga ja on ümbritsetud ka topeltjutumärkidega.

Kõigil C-keele andmetel on oma tüüp. Teatud tüüpi muutujad võtavad mälus ruumi, mis sõltub tüübist. C-s puudub selge mälumahu määramine teatud tüüpidele. See on ette nähtud konkreetse kompilaatori rakendamiseks konkreetse platvormi jaoks. Näiteks muutuja nagu int ühes kompilaatoris võib see mälus hõivata 16 bitti, teises - 32 bitti, kolmandas - 8 bitti. Kõik määrab konkreetne koostaja. Tõsi, kõik püüdlevad universaalsuse poole ja põhimõtteliselt enamikus koostajatest tüüpi int , näiteks võtab 2 baiti ja tüüp char - üks.

Olen viimasel ajal veidi loll olnud, ma ei mäletanud, mitu baiti üks tüüp enda alla võtab kahekordne V AVR-GCC. Tavaliselt töötate kontrollerite programmeerimisel täisarvu tüüpidega, nt int Ja char ja te ei kasuta sageli ujukomatüüpe nende ressursitarbimise tõttu.

Seetõttu jätan endale edaspidiseks meeldetuletuse, mis näitab AVR-GCC kompilaatori andmetüüpide poolt hõivatud mälu suurust ja seda tüüpi muutujate muutuste ulatust.

Andmetüübid C-keeles AVR-GCC kompilaatori jaoks

Märge

Tüübi rakendamine kahekordne AVR-GCC erineb standardist. Vastavalt standardile kahekordne võtab enda alla 64 bitti. AVR-GCC-s võtab seda tüüpi muutuja 32 bitti ja vastavalt sellele on see samaväärne tüübiga muutujaga ujuk!

Lisaks sellele tutvustavad AVR-GCC teegid mitmeid standardtüüpide tuletisi. Neid on failis kirjeldatud stdint.h . Tõenäoliselt tehti seda selguse parandamiseks ja programmide teksti vähendamiseks (kiirestamaks nende kirjutamist :)). Siin on vastavusplaat:

Tuletatud tüübid standardsetest tüüpidest C-keeles AVR-GCC kompilaatori jaoks

Tühi tüüp

C-keeles on veel üks tüüp – tüüp tühine . Tühine kasutatakse näitamaks, et funktsioon ei tagasta midagi või ei võta sisendiks ühtegi parameetrit. Seda tüüpi ei kasutata muutujate deklareerimiseks, seega ei võta see mäluruumi.

Viimane uuendus: 17.09.2017

Igal muutujal on teatud tüüp. Ja see tüüp määrab, millised väärtused muutujal võivad olla, milliseid toiminguid saab sellega teha ja mitu baiti see mälus hõivab. Järgmised põhiandmetüübid on määratletud C++ keeles:

bool : Boolean tüüp. Võib võtta ühe kahest väärtusest: tõene ja väär. Selle tüübi mälumaht pole täpselt määratletud.

char : tähistab ühte ASCII-märki. Mahutab mälus 1 baidi (8 bitti). Saab salvestada mis tahes väärtuse vahemikus -128 kuni 127 või vahemikus 0 kuni 255

märgiga märk : tähistab ühte tähemärki. Mahutab mälus 1 baidi (8 bitti). Saab salvestada mis tahes väärtust vahemikus -128 kuni 127

unsigned char : tähistab ühte märki. Mahutab mälus 1 baidi (8 bitti). Saab salvestada mis tahes väärtuse vahemikus 0 kuni 255

wchar_t : esindab laia tähemärki. Windowsis võtab see 2 baiti (16 bitti) mälu, Linuxis 4 baiti (32 bitti). Saab salvestada mis tahes väärtuse vahemikus 0 kuni 65 535 (2 baidi jaoks) või 0 kuni 4 294 967 295 (4 baidi jaoks)

char16_t : tähistab ühte Unicode'i tähemärki. Mahutab mälus 2 baiti (16 bitti). Saab salvestada mis tahes väärtuse vahemikus 0 kuni 65 535

char32_t : tähistab ühte Unicode'i tähemärki. Mahutab mälus 4 baiti (32 bitti). Saab salvestada mis tahes väärtuse vahemikus 0 kuni 4 294 967 295

lühike : tähistab täisarvu vahemikus –32768 kuni 32767. Mälu hõivab 2 baiti (16 bitti).

Sellel tüübil on ka sünonüümid short int, signed short int, signed short.

unsigned short: tähistab täisarvu vahemikus 0 kuni 65535. Võtab 2 baiti (16 bitti) mälu.

Sellel tüübil on ka sünonüüm unsigned short int .

int: tähistab täisarvu. Sõltuvalt protsessori arhitektuurist võib see hõivata 2 baiti (16 bitti) või 4 baiti (32 bitti). Piirväärtuste vahemik võib vastavalt varieeruda ka vahemikus –32768 kuni 32767 (2 baidiga) või –2 147 483 648 kuni 2 147 483 647 (4 baidiga). Kuid igal juhul peab suurus olema suurem või võrdne lühikese tüübi suurusega ja väiksem või võrdne pika tüübi suurusega

Sellel tüübil on sünonüümid signed int ja signed .

unsigned int : tähistab positiivset täisarvu. Olenevalt protsessori arhitektuurist võib see hõivata 2 baiti (16 bitti) või 4 baiti (32 bitti) ja seetõttu võib piirväärtuste vahemik varieeruda: 0 kuni 65535 (2 baiti puhul) või alates 0 kuni 4 294 967 295 (4 baidi jaoks).

unsigned saab kasutada selle tüübi sünonüümina

pikk : tähistab täisarvu vahemikus –2 147 483 648 kuni 2 147 483 647. Mälu hõivab 4 baiti (32 bitti).

Sellel tüübil on ka sünonüümid long int , signed long int ja signed long

märgita pikk: tähistab täisarvu vahemikus 0 kuni 4 294 967 295. Mälu hõivab 4 baiti (32 bitti).

Kas sünonüüm unsigned long int .

pikk pikk: tähistab täisarvu vahemikus −9 223 372 036 854 775 808 kuni +9 223 372 036 854 775 807. Tavaliselt hõivab 8 baiti (64 bitti) mälu.

Omab sünonüüme long long int , signed long long int ja signed long long .

märgita pikk pikk : tähistab täisarvu vahemikus 0 kuni 18 446 744 073 709 551 615. Tavaliselt võtab see 8 baiti (64 bitti) mälu.

Kas sünonüüm unsigned long long int .

float : esindab ühe täpsusega ujukoma reaalarvu vahemikus +/- 3,4E-38 kuni 3,4E+38. Mahutab mälus 4 baiti (32 bitti).

double : esindab topelttäpsusega ujukoma reaalarvu vahemikus +/- 1,7E-308 kuni 1,7E+308. Mahutab mälus 8 baiti (64 bitti).

long double : esindab topelttäpsusega ujukoma reaalarvu, mis on vähemalt 8 baiti (64 bitti). Sõltuvalt hõivatud mälu suurusest võib kehtivate väärtuste vahemik erineda.

tühine : tüüp ilma väärtuseta

Seega saab kõik andmetüübid peale void jagada kolme rühma: märgid (char, wchar_t, char16_t, char32_t), täisarv (short, int, long, long long) ja ujukomaarvu tüübid (float, double, long double).

Tegelaste tüübid

Rakenduses märkide tähistamiseks kasutatavad tüübid on char, wchar_t, char16_t ja char32_t.

Määratleme mitu muutujat:

Char c="d"; wchar_t d="c";

Char-muutuja väärtuseks on üks märk üksikjutumärkides: char c ="d" . Saate määrata ka numbri ülaltoodud loendis määratud vahemikust: char c = 120 . Sel juhul on muutuja c väärtuseks märk, mille ASCII märgitabelis on kood 120.

Tasub arvestada, et wchar_t märkide väljastamiseks konsooli ei tohiks kasutada std::cout, vaid std::wcout voogu:

#kaasa int main() ( char a = "H"; wchar_t b = "e"; std::wcout<< a << b << "\n"; return 0; }

Sel juhul võib voog std::wcout töötada nii char kui ka wchar_t-ga. Ja muutuja wchar_t voog std::cout väljastab märgi asemel numbrikoodi.

C++11 standard lisas tüübid char16_t ja char32_t, mis on orienteeritud Unicode'i kasutamisele. Nende tüüpidega töötamiseks mõeldud lõime pole aga OS-i tasemel veel rakendatud. Seega, kui teil on vaja konsoolis kuvada seda tüüpi muutujate väärtused, peate muutma muutujad tüüpideks char või wchar_t:

#kaasa int main() ( char a = "H"; wchar_t b = "e"; char16_t c = "l"; char32_t d = "o"; std::cout<< a << (char)b << (char)c << (char)d << "\n"; return 0; }

Sel juhul eelneb muutujatele väljastamisel char tüüpi cast - (char) , mille tõttu muutujate b, c ja d väärtused teisendatakse char tüübiks ja neid saab väljastada konsooli kasutades std::cout voogu.

Täisarvude tüübid

Täisarvude tüüpe esindavad järgmised tüübid: lühike, märgita lühike, int, märgita int, pikk, märgita pikk, pikk pikk ja märgita pikk pikk:

Lühike a = -10; märgita lühike b= 10; int c = -30; märgita int d = 60; pikk e = -170; märgita pikk f = 45; pikk pikk g = 89;

Ujukomaarvude tüübid

Ujukoma- ja murdarvutüüpe esindavad ujukoma, topelt- ja pikad topelt:

Ujuk a = -10,45; kahekordne b = 0,00105; pikk topelt c = 30,890045;

Andmetüüpide suurused

Ülaltoodud loend näitab iga tüübi jaoks mälus olevat suurust. Tasub aga tähele panna, et kompilaatorite arendajad saavad tüüpide suurusepiiranguid valida iseseisvalt, lähtudes arvuti riistvaralistest võimalustest. Standard määrab ainult minimaalsed väärtused, mis peaksid olema. Näiteks int ja lühikese tüübi puhul on minimaalne väärtus 16 bitti, pika tüübi puhul 32 bitti ja pika topelttüübi puhul. Sel juhul ei tohi pika tüübi suurus olla väiksem kui int tüübi suurus ja int tüübi suurus ei tohi olla väiksem kui lühikese tüübi suurus ning pika topelttüübi suurus peab olla suurem kui kahekordne. Näiteks Windowsi jaoks mõeldud g++ kompilaator kasutab pikkade kahekordistuste jaoks 12 baiti ning Visual Studiosse sisseehitatud ja ka Windowsi all töötav kompilaator kasutab pikkade kahekordistuste jaoks 8 baiti. See tähendab, et isegi sama platvormi piires võivad erinevad kompilaatorid läheneda teatud andmetüüpide suurusele erinevalt. Kuid üldiselt kasutatakse andmetüüpide kirjeldamisel ülaltoodud suurusi.

Siiski on olukordi, kus on vaja täpselt teada teatud tüüpi suurust. Ja selleks on C++-l operaator sizeof(), mis tagastab muutuja hõivatud mälu suuruse baitides:

#kaasa int main() ( pikk topeltarv = 2; std::cout<< "sizeof(number) =" << sizeof(number); return 0; }

Konsooli väljund g++-s kompileerimisel:

suurus(arv) = 12

Samas on muutujate defineerimisel oluline mõista, et muutuja väärtus ei tohiks ületada selle tüübi jaoks ette nähtud piire. Näiteks:

Signeerimata lühinumber = -65535;

G++ kompilaator genereerib selle reaga programmi kompileerimisel veateate, mis teatab, et väärtus -65535 ei ole allkirjastamata lühikese tüübi kehtivate väärtuste vahemikus ja see kärbitakse.

Visual Studios võib kompileerimine kulgeda ilma vigadeta, kuid numbrimuutuja saab väärtuse 2 - numbri -65535 teisendamise tulemuseks märgita lühitüübiks. See tähendab, et tulemus ei ole jällegi see, mida oodatakse. Muutuja väärtus on lihtsalt kogum mälus olevaid bitte, mida tõlgendatakse vastavalt konkreetsele tüübile. Ja eri tüüpide puhul saab sama bittide komplekti tõlgendada erinevalt. Seetõttu on muutujale väärtuse määramisel oluline arvestada antud tüübi väärtusvahemikke.

automaatne määraja

Mõnikord võib väljenduse tüübi kindlaksmääramine olla keeruline. Ja vastavalt uusimatele standarditele saate lasta kompilaatoril järeldada objekti enda tüüpi. Ja selleks kasutatakse automaatset määrajat. Veelgi enam, kui defineerime muutuja automaatse spetsifikaatoriga, tuleb see muutuja lähtestada mõne väärtusega:

Auto number = 5;

Määratud väärtuse põhjal järeldab kompilaator muutuja tüübi. Automaatse spetsifikaatoriga initsialiseerimata muutujad pole lubatud.

Programmeerimisel on andmetüüp kahe komplekti kogum: väärtuste komplekt ja toimingute kogum, mida saab neile rakendada. Näiteks liitmise (+), korrutamise (*), täisarvu jagamise (/), jäägi (%) ja lahutamise (−) tehteid saab rakendada mittenegatiivsele täisarvulisele andmetüübile, mis koosneb naturaalarvude lõplikust hulgast.

Programmeerimiskeelel on tavaliselt primitiivsete andmetüüpide komplekt – tüübid, mida programmeerimiskeel pakub sisseehitatud põhiseadmena. C++ keeles nimetab keele looja selliseid tüüpe põhitüüpideks. C++ põhitüübid on järgmised:

• boolean(bool);
• märk (nt char);
• int (nt int);
• ujukoma (nt ujuk);
• loendused (määratleb programmeerija);
• tühine.

Lisaks loetletutele ehitatakse järgmised tüübid:

• demonstratiivne (nt int*);
• massiivid (nt char);
• viide (nt topelt&);
• muud struktuurid.

Liigume edasi literaali mõiste juurde (näiteks 1, 2.4F, 25e-4, 'a' jne): literaal on programmi lähtekoodi kirje, mis esindab kindlat väärtust. Teisisõnu, literaal on lihtsalt mingit tüüpi objekti (väärtuse) esitus programmikoodis. C++-l on võimalus kirjutada täisarvu, ujukoma, tähemärgi, tõeväärtuse ja stringi väärtusi.

Täisarvu tüüpi literaali saab kirjutada järgmiselt:

• 10. numbrisüsteem. Näiteks 1205 ;
• 8. numbrisüsteem formaadis 0 + number. Näiteks 0142;
• 16. numbrisüsteem formaadis 0x + number. Näiteks 0x2F.

24, 030, 0x18 – need on kõik sama numbri kirjed erinevates numbrisüsteemides.
Ujukomaarvude kirjutamiseks kasutage punktimärki: 0,1, .5, 4. - kas
eksponentsiaalne märge - 25e-100. Sellises kirjes ei tohiks tühikuid olla.

Nime, millega saame seostada literaalides kirjutatud väärtusi, nimetatakse muutujaks. Muutuja on nimega või muul viisil adresseeritav mäluala, mille aadressi saab kasutada andmetele juurdepääsuks. Need andmed kirjutatakse, kirjutatakse ümber ja kustutatakse mällu teatud viisil programmi täitmise ajal. Muutuja võimaldab igal ajal andmetele juurde pääseda ja neid vajadusel muuta. Andmeid, mida saab muutuja nime järgi hankida, nimetatakse muutuja väärtuseks.
Et muutujat programmis kasutada, tuleb see deklareerida, vajadusel saab seda defineerida (= initsialiseerida). Muutuja deklaratsioon programmi tekstis sisaldab tingimata 2 osa: baastüüp ja deklaraator. Täpsustaja ja lähtestaja on valikulised osad:

Const int näide = 3; // siin const on spetsifikaator // int on põhitüüp // näide on muutuja nimi // = 3 - initsialiseerija.

Muutuja nimi on tähemärkide jada, mis koosneb ladina tähestiku tähtedest (väike- ja suurtähed), numbritest ja/või alakriipsust, kuid esimene märk ei saa olla number. Muutuja nimi tuleks valida nii, et oleks alati lihtne ära arvata, mida see salvestab, näiteks “monthPayment”. Märkustes ja praktikas kasutame muutujate salvestamise reeglite jaoks CamelCase tähistust. Muutuja nimi ei saa kattuda keeles reserveeritud sõnadega; selliste sõnade näited on: if, while, function, goto, switch jne.

Lisaks muutuja nimele võib deklaraator sisaldada täiendavaid märke:

• * - osuti; nime ees;
• *const - konstantne osuti; nime ees;
• & - link; nime ees;
• - massiiv; pärast nime;
• () - funktsioon; nime järele.

Initsialiseerija võimaldab määrata muutujale väärtuse kohe pärast selle deklareerimist. Initsialiseerija alustab võrdusliteraaliga (=) ja jätkab seejärel muutuja väärtuse määramisega. Üldiselt tähistab võrdusmärk C++ keeles määramistehet; selle abil saab määrata ja muuta muutuja väärtust. See võib eri tüüpide puhul olla erinev.

Täpsustaja määrab peale tüübi täiendavaid atribuute. Näites toodud spetsifikaator const võimaldab keelata muutuja väärtuse hilisemad muudatused. Selliseid muutumatuid muutujaid nimetatakse konstantseteks või konstantseteks.

Konstandi deklareerimine ilma lähtestamiseta ei tööta loogilistel põhjustel:

Const int EMPTY_CONST; // viga, konstantset muutujat ei lähtestata const int NÄIDE = 2; // konstant väärtusega 2 NÄIDE = 3; // viga, proovige konstantsele muutujale väärtust määrata

Konstantide nimetamisel on tavaks kasutada ainult suuri tähti, eraldades sõnad alakriipsuga.

Põhilised andmetüübid keeles C++

Iga tüüpi uurides ei tohiks lugeja unustada andmetüübi definitsiooni.

1. Täisarvu tüüp (char, short (int), int, long (int), long long)

Nime järgi on lihtne aru saada, et väärtuste komplekt koosneb täisarvudest. Samuti võib iga loetletud tüüpi väärtuste komplekt olla allkirjastatud või allkirjastamata. Komplektis sisalduvate elementide arv sõltub selle tüübi väärtuse salvestamiseks kasutatava mälu suurusest. Näiteks char tüüpi muutuja jaoks eraldatakse 1 bait mälu, seega on elementide koguarv:

• 2 8N = 2 8 * 1 = 256, kus N on väärtuse salvestamiseks vajaliku mälu suurus baitides

Sel juhul on saadaolevate täisarvude vahemikud järgmised:

• - märgita märgi jaoks
• [-128..127] - märgistatud tähe jaoks

Vaikimisi loetakse täisarvuline muutuja märgituks. Märkimaks koodis, et muutuja peab olema allkirjastamata, lisatakse vasakul asuvale põhitüübile signed atribuut, s.o. allkirjastamata:

Märgita pikad väärtused; // määrab täisarvu (pika) märgita tüübi.

Loetletud tüübid erinevad ainult salvestamiseks vajaliku mälu suuruse poolest. Kuna C++ keel on üsna masinast sõltuv, tagab keelestandard ainult järgmise tingimuse:

• 1 = tähe suurus ≤ lühike suurus ≤ sisemine suurus ≤ pikk suurus.

Tavaliselt on tüüpide suurused järgmised: char - 1, short - 2, int - 4, long -8, long long - 8 baiti.

Aritmeetilisi toiminguid saate teha täisarvu tüüpi väärtustega: +, -, *, /, %; võrdlustehted: ==, !=,<=, <, >, >=; bititehted: &, |, xor,<<, >>.
Enamikku tehteid, nagu liitmine, korrutamine, lahutamine ja võrdlemine, on lihtne mõista. Mõnikord võib pärast aritmeetiliste toimingute sooritamist tulemus olla väljaspool väärtusvahemikku; sel juhul tekitab programm vea.
Täisarvu jagamine (/) otsib ühe täisarvu jagamise täisarvu teisega. Näiteks:

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

Protsendisümbol (%) tähistab kahe täisarvu jaotuse ülejäänud osa määramise toimingut:

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

Raskemini mõistetavad on bitipõhised operatsioonid: & (JA), | (OR), xor (eksklusiivne VÕI),<< (побитовый сдвиг влево), >> (bitipõhine nihe paremale).

Bitioperatsioonid JA, VÕI ja XOR rakendavad igale teabebitile vastavat loogilist operatsiooni:

• 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 või 3 10 = 01 2 x või 11 2 = 10 2

Pilditöötluses kasutatakse värvi jaoks 3 kanalit: punane, sinine ja roheline - pluss läbipaistvus, mis salvestatakse muutujasse int, kuna igal kanalil on väärtuste vahemik 0 kuni 255. Kuueteistkümnendsüsteemis kirjutatakse teatud väärtus järgmiselt: 0x180013FF; siis väärtus 18 16 vastab punasele kanalile, 00 16 - sinine, 13 16 - roheline, FF - alfa kanal (läbipaistvus). Konkreetse kanali valimiseks sellisest täisarvust kasutatakse nn kanalit. mask, kus meid huvitavad positsioonid on F 16 või 1 2. See tähendab, et sinise kanali väärtuse esiletõstmiseks tuleb kasutada maski, st. bitipõhiselt JA:

Int blue_channel = 0x180013FF & 0x00FF0000;

Pärast seda nihutatakse saadud väärtus vajaliku arvu bittide võrra paremale.

Bitinihe nihutab arvu vasakule või paremale nii mitme kahendnumbri võrra, nagu on määratud toimingu paremal küljel. Näiteks märgi tüübi arv 39 kirjutatakse binaarselt järgmiselt: 00100111. Seejärel:

Char binaryNäide = 39; // 00100111 char result = binaryExample<< 2; // сдвигаем 2 бита влево, результат: 10011100

Kui muutuja on märgita tüüpi, on tulemuseks arv 156, märgiga muutuja puhul on see võrdne -100. Pange tähele, et märgiga täisarvu tüüpide puhul on biti esituse kõige olulisemas bitis olev ühik märk sellest, et arv on negatiivne. Sel juhul vastab binaarkujuline väärtus, mis koosneb kõigist ühtedest, väärtusele -1; kui 1 on ainult kõige olulisemas numbris ja ülejäänud numbrid on nullid, siis on sellisel arvul teatud tüüpi minimaalne väärtus: tähe puhul on see -128.

2. Ujukoma tüüp (ujuk, topelt (ujuk))

Ujukomaväärtuste komplekt on reaalarvude alamhulk, kuid mitte iga reaalarv ei ole kahendarvuna esitatav, mis mõnikord põhjustab rumalaid vigu:

Ujuv väärtus = 0,2; väärtus == 0,2; // viga, väärtus siin ei võrdu 0,2-ga.

Ujukomamuutujatega töötades ei tohiks programmeerija kasutada võrdsuse või ebavõrdsuse testi, selle asemel kasutatakse tavaliselt teatud intervalli jäämise testi:

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

Lisaks võrdlustehtetele toetab ujukomatüüp 4 aritmeetilisi tehteid, mis vastavad täielikult matemaatilistele tehtetele reaalarvudega.

3. Boole'i ​​(loogiline) tüüp (bool)

Koosneb ainult kahest väärtusest: true (true) ja false (false). Seda tüüpi muutujatega töötamiseks kasutatakse loogilisi tehteid: ! (EI), == (võrdsus), != (ebavõrdsus), && (loogiline JA), || (loogiline VÕI). Iga toimingu tulemuse leiab vastavast tõesuse tabelist. Näiteks:

4. Tähemärgi tüüp (char, wchar_t)

Märgi tüüp ei ole ainult täisarvu tüüp (tavaliselt nimetatakse seda tüüpi bait), vaid ka märgitüüp, mis salvestab tabelis oleva märginumbri ASCII-märgina. Näiteks kood 0x41 vastab märgile "A" ja 0x71 - "t".

Mõnikord on vaja kasutada märke, mis pole ASCII-tabelites fikseeritud ja nõuavad seetõttu salvestamiseks rohkem kui 1 baiti. Nende jaoks on lai märk (wchar_t).

5.1. Massiivid

Massiivid võimaldavad salvestada sama tüüpi elementide järjestikust komplekti. Massiiv salvestatakse mällu külgneva plokina, seega ei saa massiivi deklareerida ilma selle suurust määramata. Massiivi deklareerimiseks kirjutatakse muutuja nime järele nurksulud (), mis näitab selle suurust. Näiteks:

Int myArray; // 5 täisarvu tüüpi elemendi massiiv

Massiivi lähtestamiseks on väärtused loetletud lokkis sulgudes. Sel viisil saate lähtestada ainult muutuja deklareerimise ajal. Muide, sel juhul pole massiivi suurust vaja määrata:

Keskmine koefitsient = (1, 3, 7, 9, 11); // Massiivi lähtestatakse 5 väärtusega

Massiivi (massiivi elemendi) konkreetsele väärtusele juurde pääsemiseks kasutage indeksi juurdepääsutoimingut (), mis näitab elemendi numbrit (numbrid algavad 0-st). Näiteks:

Koefitsiendid; // juurdepääs massiivi esimesele elemendile. Tagastab väärtuse 1 koefitsient; // juurdepääs kolmandale elemendile. Tagastab väärtuse 7 koefitsient = 13; // Massiivi koefitsientide 5. elemendile uue väärtuse määramine; // juurdepääsu viga

5.3. Stringid

Stringi kirjutamiseks kasutavad programmeerijad ideed, et string on märkide järjestikune jada (massiivi). Rea lõpu tuvastamiseks kasutage spetsiaalset rea lõpu märki: '\0'. Neid erimärke, mis koosnevad kaldkriipsust ja identifitseerivast märgist, nimetatakse juht- või paomärkideks. Samuti on näiteks '\n' - uue rea algus, '\t' - tabel. Stringi kaldkriipsu kirjutamiseks kasutatakse paoklahvi – märgi enda ette asetatakse teine ​​kaldkriips: ‘\’. Põgenemist kasutatakse ka jutumärkide kirjutamiseks.

Loome stringi muutuja:

Char textExample = ('T', 'e', ​​'s', 't', '\0'); // kirjutatakse string "Test".

Stringi lähtestamiseks on lihtsustatud märge:

Char textExample = "Testi"; // Viimast tähemärki ei kirjutata, aga suurus on ikkagi 5

Üksikasjadesse laskumata on siin veel üks kasulik andmetüüp - string. Stringid
Seda tüüpi saab lisada näiteks:

String tere = "Tere,"; string name = "Max!"; string tere_nimi = tere + nimi; // Hangi string "Tere, Max!"

6. Link

Int a = 2; // muutuja "a" osutab väärtusele 2 int &b = a; // muutuja “b” osutab samale kohale kui “a” b = 4; // muutes b väärtust, muudab programmeerija a väärtust. Nüüd a = 4 int & c = 4; // viga, sa ei saa seda teha, sest viitele ei saa väärtust määrata

7. Indeks

Selle andmetüübi mõistmiseks peate meeles pidama, et paljud seda tüüpi väärtused on nende mälurakkude aadressid, kust andmed algavad. Kursor toetab ka liitmise (+), lahutamise (-) ja viitamise (*) toiminguid.

Aadressid 0x0 tähendab, et kursor on tühi, st. ei viita ühelegi andmetele. Sellel aadressil on oma sõnasõna - NULL:

Int *nullPtr = NULL; // null osuti

Aadressi liitmine ja lahutamine täisarvu või mõne muu aadressiga võimaldab
programmi käsutuses olevas mälus ringi liikuda.

Andmete otsimist, mis algab osutisse salvestatud aadressilt, nimetatakse viitamise tühistamiseks (*). Programm loeb vajaliku arvu mälurakke ja tagastab mällu salvestatud väärtuse.

Int valueInMemory = 2; // määrab täisarvu tüüpi muutuja int *somePtr = // kopeeri muutuja aadress, siin & - tagastab muutuja aadressi somePtr; // mäluelemendi aadress, näiteks 0x2F *somePtr; // väärtus salvestatakse 4 lahtrisse: 0x2F, 0x30, 0x31 ja 0x32

Omistamistoiming, mis on süntaktiliselt sama mis kopeerimistoiminguga, pole osutite jaoks saadaval. Teisisõnu saate kopeerida mõne teise osuti aadressi või muutuja aadressi, kuid te ei saa ise määrata aadressi väärtust.

Kursor ise salvestatakse mällu, nagu ka muud tüüpi muutujate väärtused, ja see võtab enda alla 4 baiti, nii et saate kursorile kursori luua.

8. Ülekanded

Loendid on ainus programmeerija poolt määratletud põhitüüp. Üldiselt on loend nimega täisarvuliste konstantide järjestatud kogum, mille põhitüüp on loendi nimi.

Enum värv (PUNANE, SININE, ROHELINE);

Vaikimisi PUNANE = 0, SININE = 1, ROHELINE = 2. Seetõttu saab väärtusi omavahel võrrelda, st. PUNANE< BLUE < GREEN. Программист при объявлении перечисления может самостоятельно задать значения каждой из констант:

Enum juurdepääs (LOE = 1, KIRJUTA = 2, EXEC = 4);

Sageli on mugav kasutada loendeid, mille väärtused on kahe astmed, sest binaarses esituses koosneb 2 astmega arv 1-st ja nullidest. Näiteks:

8 10 = 00001000 2

Nende numbrite liitmise tulemus näitab alati selgelt, millised numbrid lisati:

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

Tühine

Süntaktiliselt kuulub tühitüüp põhitüüpide hulka, kuid seda saab kasutada ainult keerukamate tüüpide osana, kuna Tühi tüüpi objekte pole. Tavaliselt kasutatakse seda tüüpi näitamaks, et funktsioonil ei ole tagastusväärtust, või on see määramata tüüpi objektide kursori põhitüüp:

tühi objekt; // viga, void void tüüpi objekte pole // error, ei ole viiteid void void *ptr; // ok, salvesta kursor tundmatule tüübile

Sageli kasutame void spetsiaalselt selleks, et näidata, et funktsioon ei tagasta väärtust. Tühi tüüpi kursorit kasutatakse siis, kui programmeerija võtab täieliku vastutuse mälu terviklikkuse ja õige tüübi ülekandmise eest.

Cast

Tihti on vaja üht tüüpi muutuja väärtust teisele üle kanda. Juhul, kui algtüübi väärtuste hulk on suuremat tüüpi alamhulk (näiteks int on pika alamhulk ja long on kahekordne), suudab kompilaator kaudselt ( kaudselt) muutke väärtuse tüüpi.

täisarv = 2; float floating = täisarv; // ujuv = 2,0

Pöördtüüpi cast sooritatakse teabekaoga, nii et ujukomaarvust jääb alles vaid täisarvuline osa, murdosa kaob.

Võimalik on selgesõnaline tüübi teisendamine; selleks kirjutage muutujast või algse tüübi mis tahes väärtusest vasakule sulgudesse tüüp, millele ülekandmine toimub:

Int väärtus = (int) 2,5;

Unaar- ja kahendtehted

Varem tehtud toiminguid nimetatakse binaarseteks: operatsioonisümbolist vasakul ja paremal on väärtused või muutujad, näiteks 2 + 3. Lisaks binaartehtetele kasutavad programmeerimiskeeled ka muutujatele kehtivaid unaartehteid. . Need võivad paikneda muutujast kas vasakul või paremal, selliseid operatsioone on varemgi ette tulnud - viitamise eemaldamise tehe (*) ja muutuja aadressi võtmine (&) on unaarsed. Operaatorid “++” ja “–” suurendavad ja vähendavad täisarvulise muutuja väärtust vastavalt 1 võrra ning neid saab kirjutada muutujast kas vasakule või paremale.

C++ kasutab ka binaartehteid stenogrammi juhul, kui avaldise vasak ja parem pool sisaldavad sama muutujat, s.t. muutuja väärtusega tehakse mõni toiming ja operatsiooni tulemus salvestatakse samasse muutujasse:

A += 2; // sama mis a = a + 2; b /= 5; // sama mis b = b / 5; c &= 3; // sama mis c = c & 3;