Täisarvu tüüp (int)

Tüübi suurus int ei ole standardiga määratletud, vaid sõltub arvutist ja kompilaatorist.

16-bitise protsessori jaoks on seda tüüpi väärtuste jaoks eraldatud 2 baiti,

32-bitise jaoks - 4 baiti.

täpsustaja lühike tüübinime ees näitab kompilaatorile, et numbri jaoks on vaja 2 baiti, olenemata protsessori bitiastmest.

täpsustaja pikk tähendab, et täisarvu väärtus on 4 baiti.

Seega on 16-bitises arvutis int ja short int ekvivalendid,

ja 32-bitise puhul int ja long int.

Sisemine esindus täisarvu tüüpi väärtused - täisarv kahendkoodis. Täpsustaja kasutamisel allkirjastatud arvu kõige olulisemat bitti tõlgendatakse märgina (0 - positiivne arv, 1 - negatiivne). täpsustaja allkirjastamata võimaldab esitada ainult positiivseid numbreid, kuna kõige olulisemat numbrit peetakse numbrikoodi osaks. Seega sõltub tüübi int väärtuste vahemik spetsifikaatoritest. IBM PC-ühilduvate arvutite erinevate spetsifikatsioonidega täisarvu tüüpi väärtuste vahemikud on toodud tabelis "Lihtsate andmetüüpide väärtusvahemikud".

Vaikimisi loetakse kõik täisarvu tüübid allkirjastatuks, mis tähendab, et allkirjastatud spetsifikaatori võib ära jätta.

Programmis esinevatele konstantidele määratakse vastavalt nende tüübile üks või teine ​​tüüp. Kui see mingil põhjusel programmeerijale ei sobi, saab selgesõnaliselt määrata vajaliku tüübi, kasutades järelliideid L, l (pikk) ja U, u (märgita). Näiteks konstant 32L on tüüpi pikk ja võtab enda alla 4 baiti. Saate samaaegselt kasutada järelliidet L ja U, näiteks 0x22UL või 05Lu.

Märge. Tüüpe short int, long int, signed int ja unsigned int saab lühendada vastavalt short, long, signed ja unsigned.

Tähemärgi tüüp (tähemärk)

Märgitüübi väärtus on baitide arv, mis on piisav, et mahutada antud arvuti märgistiku mis tahes tähemärki, mis viis tüübi nimeni. Tavaliselt on see 1 bait. Tähemärgi tüüp, nagu ka muud täisarvutüübid, võib olla märgistatud või märgita. Märgiga väärtused võivad salvestada väärtusi vahemikus -128 kuni 127. Märgistamata spetsifikaatori kasutamisel võivad väärtused olla vahemikus 0 kuni 255. Sellest piisab, et salvestada mis tahes tähemärki 256-kohalises ASCII märgikomplektis. char väärtusi kasutatakse ka täisarvude salvestamiseks.

Laiendatud märgitüüp (wchar_t)

Tüüp wchar_t loodud töötama kodeerimiseks mõeldud märgikomplektiga, millest 1 baidist ei piisa. Näiteks Unicode. Selle tüübi suurus sõltub rakendamisest; see sobib tavaliselt tüübiga lühike. Wchar_t tüüpi stringkonstandid kirjutatakse L-eesliitega, näiteks L"Gates".

Boole'i ​​tüüp (bool)

Tõeväärtused võivad võtta ainult väärtusi tõsi Ja vale, mis on reserveeritud sõnad. Vale sisemine esitus on 0 (null). Kõik muud väärtused tõlgendatakse tõesena. Täisarvutüübiks teisendamisel tõsi mille väärtus on 1.

Ujukomatüübid (ujukoma, kahekordne ja pikk topelt)

C++ standard määratleb reaalsete väärtuste salvestamiseks kolm andmetüüpi: float, double ja long double.

Ujukoma andmetüübid salvestatakse mällu erinevalt täisarvudest. Reaalarvu sisemine esitus koosneb kahest osast - mantiss Ja tellida.

IBM PC-ga ühilduvates arvutites on sellised väärtused nagu ujuk hõivavad 4 baiti, millest eraldatakse üks bitt mantissi märgi all, 8 numbrit tellimuse all ja 23 mantissi all. Mantiss on arv, mis on suurem kui 1,0, kuid väiksem kui 2,0. Kuna mantissi kõrgeim number on alati 1, siis seda ei salvestata.

Tüübi väärtuste jaoks kahekordne, hõivavad 8 baiti, järjestusele ja mantissile eraldatakse vastavalt 11 ja 52 bitti. Mantissi pikkus määrab arvu täpsuse, eksponendi pikkus aga selle ulatuse. Nagu näete kirje lõpus olevast tabelist, erinevad ujuv- ja pikad int väärtuste jaoks sama arvu baitide puhul nende kehtivate väärtuste vahemikud oluliselt sisemise esitusvormi tõttu.

täpsustaja pikk enne tüübi nime kahekordne näitab, et selle väärtuse jaoks on eraldatud 10 baiti.

Ujukoma konstandid on vaikimisi topelttüüpi. Konstandi tüübi saab selgesõnaliselt määrata, kasutades järelliideid F, f (float) ja L, l (pikk).

Näiteks konstant 2E+6L oleks long double tüüpi ja konstant 1.82f oleks float tüüpi.

Erinevatele platvormidele universaalseid programme kirjutades ei saa tüübi suuruse kohta oletada int. Selle saamiseks peate kasutama operaatorit sizeof, mis tagastab tüübi suuruse baitides.

Näiteks MS-DOS operatsioonisüsteemis on sizeof(int) tulemuseks 2 ja Windows 98 või OS/2 puhul on tulemuseks 4.

ANSI standard ei määra põhitüüpide väärtusvahemikke, määratletakse ainult nende suuruste suhted, näiteks:

suurus (ujuk) ≤ slzeof (double) ≤ suurus (pikk topelt)
suurus (süsi) ≤ slzeof (lühike) ≤ suurus (int) ≤ suurus (pikk)

Märge. Täisarvutüüpide minimaalsed ja maksimaalsed lubatud väärtused sõltuvad rakendamisest ja on antud päisefailis (), päristüüpide tunnused – failis (), samuti klassimallis numbrilised_piirangud

tühi tüüp

Lisaks loetletutele on tühi tüüp keele üks peamisi tüüpe, kuid seda tüüpi väärtuste komplekt on tühi. Seda kasutatakse funktsioonide määratlemiseks, mis väärtust ei tagasta, funktsiooni argumentide tühja loendi määramiseks, osutite baastüübiks ja cast-operatsioonides.

Tutvustatakse erinevaid täis- ja reaaltüüpe, mis erinevad andmete esituse ulatuse ja täpsuse poolest, et võimaldada programmeerijal konkreetse riistvara võimalusi kõige tõhusamalt kasutada, kuna arvutuste kiirus ja mälumaht oleneb tüübi valikust. Kuid ühte tüüpi arvutite jaoks optimeeritud programm võib muutuda teistele platvormidele mitteportatiivseks, seega tuleks üldiselt vältida sõltuvusi andmetüüpide spetsiifilistest omadustest.

Tüüp	Väärtuse vahemik	Suurus (bait)
bool	tõene ja vale
signeeritud char	-128 … 127
märgita täht	0 … 255
allkirjastatud lühike int	-32 768 … 32 767
allkirjastamata lühike int	0 … 65 535
allkirjastatud pikk int	-2 147 483 648 … 2 147 483 647
allkirjastamata pikk int	0 … 4 294 967 295
ujuk	3,4e-38 … 3,4e+38
kahekordne	1,7e-308 … 1,7C+308
pikk topelt	3,4e-4932 … 3,4e+4932

Programmi struktuur

C++ programm koosneb funktsioonid, kirjeldused Ja eeltöötleja direktiivid. Üks funktsioonidest tuleb nimetada peamine. Programmi täitmine algab selle funktsiooni esimese lausega. Lihtsaim funktsiooni definitsioon on järgmises vormingus:

Reeglina kasutatakse funktsiooni mingi väärtuse arvutamiseks, seega märgitakse selle tüüp enne funktsiooni nime. Allpool on kõige olulisem teave funktsioonide kohta:

• kui funktsioon ei peaks väärtust tagastama, määratakse tühi tüüp:
• funktsiooni keha on plokk ja on seetõttu ümbritsetud lokkis traksidega;
• funktsioone ei saa pesastada;
• iga väide lõpeb semikooloniga (v.a liitlause).

Näide programmi struktuurist, mis sisaldab funktsioone main, fl ja f2:

Programm võib koosneda mitmest moodulid(lähtefailid).

Märkused C++ sisendi/väljundi kohta

C++ keelel ei ole sisseehitatud I/O-rajatisi – seda tehakse standardsetes teekides sisalduvate funktsioonide, tüüpide ja objektide abil.

Kasutatakse kahte meetodit: C-keelest päritud funktsioone ja C++-objekte.

Põhilised C-stiilis I/O funktsioonid:

int scanf (const char* formaat, ...) // sisend
int printf(const char* formaat, ...) // väljund

Nad sooritavad vormindatud sisendi ja väljundi suvalise arvu väärtusi vastavalt vormingustringile. Vormingutring sisaldab märke, mis kopeeritakse voogu (ekraanil) või küsitakse voost (klaviatuurilt) sisendil, ja teisendusspetsifikatsioone, mis algavad % märgiga, mis asendatakse sisendil konkreetsete väärtustega ja väljund.

Näidisprogramm, mis kasutab C-stiilis I/O funktsioone:

#kaasa
int main() (
int i;
printf("Sisesta täisarv\n");
scanf("%d", &i);
printf("Sa sisestasid numbri %d, aitäh!", i);
tagasi 0;
}

Selle programmi esimene rida on eelprotsessori käskkiri, mille kohaselt lisatakse programmi teksti päisefail, mis sisaldab programmis kasutatavate sisend-/väljundfunktsioonide kirjeldust (sel juhul on nurksulud keele element ). Kõik eeltöötlusjuhised algavad # märgiga.

Kolmas rida on täisarvu tüüpi muutuja i kirjeldus.

Neljanda rea ​​funktsioon printf prindib käsu "Sisesta täisarv" ja hüppab uuele reale vastavalt \n paojärjestusele. Funktsioon scanf salvestab klaviatuurilt sisestatud täisarvu muutujasse i (märk & tähendab aadressi hankimise toimingut) ja järgmine lause kuvab selles määratud stringi, asendades teisendusspetsifikatsiooni selle numbri väärtusega.

Programm, mis kasutab C++ klassi raamatukogu:

#kaasa
int main() (
int i;
cout<< "Введите целое число\n"; cin >> i;
cout<< "Вы ввели число " << i << ", спасибо!";
tagasi 0;
}

Päisefail sisaldab sisendi/väljundi haldamiseks mõeldud klasside komplekti kirjeldust. See määratleb standardsed vooobjektid cin klaviatuuri sisendiks ja cout nii ekraanil kuvamiseks kui ka voogesitustoiminguteks< < и чтения из потока >>.

Saate kasutada mõlemat sisendi / väljundi korraldamise meetodit, kuid pole soovitatav neid ühes programmis segada.

Andmetüüp programmeerimisel on kahe komplekti kogum: väärtuste kogum ja toimingute komplekt, mida saab neile rakendada. Näiteks mittenegatiivset täisarvu andmetüüpi, mis koosneb naturaalarvude lõplikust hulgast, saab rakendada liitmise (+), korrutamise (*), täisarvu jagamise (/), jäägi (%) ja tehtetele. lahutamine (−).

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 tähemärk);
• täisarv (nt int);
• ujukoma (nt ujuk);
• enums (määratleb programmeerija);
• tühine.

Lisaks ülaltoodule ehitatakse järgmised tüübid:

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

Liigume edasi literaali mõiste juurde (nt 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äisarvväärtusi, ujukomaväärtusi, märke, tõeväärtusi, stringivää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 on kõik sama numbri kirjed erinevates numbrisüsteemides.
Ujukomaarvude kirjutamiseks kasutatakse punktimärki: 0,1, .5, 4. - kas
eksponentsiaalne märge - 25e-100. Sellises kirjes ei tohiks tühikuid olla.

Nime, millega saame seostada literaalide kirjutatud väärtusi, nimetatakse muutujaks. Muutuja on nimega või muul viisil adresseeritav koht mälus, mille aadressi abil saab andmetele ligi pääseda. Need andmed kirjutatakse, kirjutatakse üle ja kustutatakse mällu teatud viisil programmi täitmise ajal. Muutuja võimaldab igal ajal andmetele ligi 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: põhitüüp ja deklaraator. Täpsustaja ja lähtestaja on valikulised osad:

const int näide = 3; // siin const - spetsifikaator // int - baastüüp // näide - muutuja nimi // = 3 - initsialiseerija.

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

Deklaator võib lisaks muutuja nimele 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 muutuja väärtuse kohe pärast deklaratsiooni. Initsialiseerija algab võrdusliteraaliga (=) ja seejärel toimub muutuja väärtuse määramise protsess. Üldiselt tähistab võrdusmärk C++ keeles määramistehet; seda saab kasutada muutuja väärtuse määramiseks ja muutmiseks. 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, konstantne muutuja ei ole lähtestatud 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 suurtähti, eraldades sõnad alakriipsuga.

C++ põhiandmetüübid

Iga tüübi lahkamisel peab lugeja meeles pidama andmetüübi määratlemist.

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 (allkirjastatud) või allkirjastamata (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, nii et elementide koguarv on:

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

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

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

Vaikimisi loetakse täisarvu tüüpi muutujat allkirjastatuks. Märkimaks koodis, et muutuja peaks olema märgita, määratakse vasakul asuvale põhitüübile allkirjastatud märk, s.t. allkirjastamata:

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

Loetletud tüübid erinevad ainult salvestamiseks vajaliku mälumahu poolest. Kuna C++ keel on üsna masinaspetsiifiline keelestandard, tagab see 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 tehteid saab teha täisarvu tüüpi väärtustega: +, -, *, /, %; võrdlustehted: ==, !=,<=, <, >, >=; bititehted: &, |, xor,<<, >>.
Enamik tehteid, nagu liitmine, korrutamine, lahutamine ja võrdlustoimingud, on kergesti mõistetavad. Mõnikord võib pärast aritmeetiliste toimingute sooritamist tulemus olla väljaspool väärtusvahemikku; sel juhul annab programm veateate.
Täisarvu jagamine (/) leiab täisarvu jagamise täisarvu teisega. Näiteks:

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

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

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

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

Bititehted 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 tüüpi, kuna igal kanalil on väärtuste vahemik 0 kuni 255. Kuueteistkümnendsüsteemis kirjutatakse väärtus järgmiselt: 0x180013FF; siis väärtus 18 16 vastab punasele kanalile, 00 16 - sinine, 13 16 - roheline, FF - alfa kanal (läbipaistvus). Sellise täisarvu hulgast kindla kanali valimiseks kasutage nn. 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 sinine_kanal = 0x180013FF & 0x00FF0000;

Pärast seda nihutatakse vastuvõetud väärtust vajaliku arvu bittide võrra paremale.

Bitisuunaline nihe nihutab vasakule või paremale nii palju arvu bitte, nagu on määratud operatsiooni paremal küljel. Näiteks kahendvormingus märgitüübi arv 39 kirjutatakse 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 korral võrdub see -100-ga. Pange tähele, et märgiga täisarvu tüüpide puhul on bittide esituse kõrgeimas järjekorras 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 väärtuse jaoks 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 reaalarvu ei saa esitada kahendarvuna, mis mõnikord põhjustab rumalaid vigu:

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

Ujukomamuutujatega töötades ei tohiks programmeerija kasutada võrdsuse või ebavõrdsuse operatsiooni, selle asemel kasutavad nad tavaliselt teatud intervalli tabamiseks testi:

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

Lisaks võrdlustehtetele toetab ujukomatüüp 4 aritmeetilisi tehteid, mis on täielikult kooskõlas reaalarvudega matemaatiliste tehtetega.

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:

X Y XOR0 0 0 0 1 1 1 0 1 1 1 0

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

Märgi tüüp ei ole mitte ainult täisarv (tavaliselt nimetatakse sellist 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-tabelis fikseeritud ja vajavad seetõttu rohkem kui 1 baiti salvestamiseks. 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ülgnevas plokis, seega ei saa massiivi deklareerida ilma selle suurust määramata. Massiivi deklareerimiseks kirjutage muutuja nime järele nurksulud (), mis näitavad 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 initsialiseerida ainult muutuja deklareerimise ajal. Muide, sel juhul pole massiivi suurust vaja määrata:

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

Massiivi (massiivi elemendi) konkreetsele väärtusele juurdepääsuks kasutage indeksi juurdepääsutoimingut () elemendi numbriga (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 kujutab endast järjestikust märkide jada (massiivi). Rea lõpu tuvastamiseks kasutatakse spetsiaalset rea lõpu märki: '\0'. Neid erimärke, mis koosnevad kaldkriipsust ja identifitseerivast märgist, nimetatakse juht- või paomärkideks. Ikka on näiteks '\n' - uue rea algus, '\t' - tabel. Rea kaldkriipsu salvestamiseks kasutatakse paoklahvi – märgi enda ette pannakse teine ​​kaldkriips: '\'. Põgenemist kasutatakse ka jutumärkide kirjutamiseks.

Loome stringi muutuja:

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

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 saate lisada näiteks:

String tere = "Tere, "; stringname = "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. Osuti

Seda tüüpi andmetega tegelemiseks tuleb meeles pidada, et seda tüüpi väärtuste komplekt on mälurakkude aadressid, kust andmed algavad. Kursor toetab ka liitmise (+), lahutamise (-) ja viitamise tühistamise (*) 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 hankimise toimingut, 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 on salvestatud 4 lahtrisse: 0x2F, 0x30, 0x31 ja 0x32

Osutite puhul pole määramistoiming, mis on süntaktiliselt sama mis kopeerimistoiminguga, 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 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äisarvukonstantide järjestatud kogum, kusjuures loendi nimi on põhitüüp.

Enumcolor (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 (READ=1, WRITE=2, EXEC=4);

Sageli on mugav kasutada loendeid, mille väärtused on kahe astmega, sest binaarses esituses koosneb arv, mis on astme 2, 1. ühikust 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 on tühitüüp üks põhitüüpe, kuid seda saab kasutada ainult keerukamate tüüpide osana, kuna void tüüpi objekte ei eksisteeri. Tavaliselt kasutatakse seda tüüpi teavitamiseks, et funktsioonil pole tagastusväärtust, või määramata tüüpi objektidele osutava kursori baastüübina:

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ühitüübi osutit käsitletakse 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 komplekt on suuremat tüüpi alamhulk (näiteks int on pika alamhulk ja long on kahekordne), saab kompilaator kaudselt ( kaudselt) muutke väärtuse tüüpi.

int täisarv = 2; ujuv ujuv = täisarv; // ujuv = 2,0

Tüübi teisendamine toimub teabe kaoga, seega jääb ujukomaarvust alles vaid täisarvuline osa, murdosa kaob.

Võimalik on selgesõnaline (eksplitsiitne) tüübiteisendus, selleks kirjutage muutujast või mõnest algse tüübi väärtusest vasakule sulgudesse tüüp, millele ülekandmine tehakse:

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

Unaar- ja kahendtehted

Neid toiminguid, mida me varem tegime, nimetatakse binaarseteks: operatsioonisümbolist vasakul ja paremal on väärtused või muutujad, näiteks 2 + 3. Lisaks binaartehtetele kasutavad programmeerimiskeeled ka unaartehteid. mis kehtivad muutujate kohta. Need võivad olla muutujast kas vasakul või paremal pool, selliseid operatsioone on varemgi ette tulnud - viitamise 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 kahendtehte puhul stenogrammi, kui avaldise vasak ja parem pool sisaldavad sama muutujat, st. mõni toiming tehakse muutuja väärtusega ja toimingu 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;

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 : Boole'i ​​tüüp. See võib võtta ühe kahest väärtusest tõene (tõene) ja väär (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 0 kuni 255

märgiga märk : tähistab ühte märki. Mahutab mälus 1 baidi (8 bitti). Saab salvestada mis tahes väärtuse 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 : tähistab laia tähemärki. Windowsis võtab see mälus 2 baiti (16 bitti), Linuxis 4 baiti (32 bitti). Saab salvestada mis tahes väärtuse vahemikus 0 kuni 65535 (2 baidi jaoks) või 0 kuni 4294967295 (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 65535

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 4294967295

lühike : tähistab täisarvu vahemikus -32768 kuni 32767. Mälus 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. Mälus hõivab 2 baiti (16 bitti).

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

int : tähistab täisarvu. Olenevalt protsessori arhitektuurist võib see võtta 2 baiti (16 bitti) või 4 baiti (32 bitti). Piirväärtuste vahemik võib vastavalt varieeruda vahemikus -32768 kuni 32767 (2 baidi puhul) või -2 147 483 648 kuni 2 147 483 647 (4 baidi puhul). 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. Sõltuvalt protsessori arhitektuurist võib see võtta 2 baiti (16 bitti) või 4 baiti (32 bitti) ja seetõttu võib piirväärtuste vahemik varieeruda: 0 kuni 65535 (2 jaoks baiti) või 0 kuni 4 294 967 295 (4 baidi puhul).

Unsigned võib kasutada selle tüübi sünonüümina.

pikk : tähistab täisarvu vahemikus −2147483648 kuni 2147483647. 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).

Omab sünonüümi sõnale unsigned long int .

pikk pikk : tähistab täisarvu vahemikus −9223372036854775808 kuni +9223372036854775807. Tavaliselt on mälus 8 baiti (64 bitti).

Sisaldab 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 18446744073709551615. Tavaliselt on mälus 8 baiti (64 bitti).

Omab sünonüümi sõnale unsigned long long int .

ujuk : tähistab tavalist täppisujukomaarvu vahemikus +/- 3,4E-38 kuni 3,4E+38. Võtab mälus 4 baiti (32 bitti).

double : esindab topelttäpsusega ujukomaarvu vahemikus +/- 1,7E-308 kuni 1,7E+308. Võtab mälus 8 baiti (64 bitti).

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

void : 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 ujukomatüübid (float, double, long double).

Tegelaste tüübid

Rakendus kasutab märkide esitamiseks tüüpe char , wchar_t , char16_t ja char32_t.

Määratleme mõned muutujad:

Charc="d"; wchar_td="c";

Tüüpi char muutuja väärtuseks on üks märk jutumä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; }

Samal ajal saab std::wcout voog töötada nii char kui ka wchar_t-ga. Ja muutuja wchar_t voog std::cout kuvab märgi asemel selle numbrikoodi.

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

#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 väljund muutujatele cast to char - (char) , nii et muutujate b, c ja d väärtused teisendatakse chariks ja neid saab printida konsooli kasutades std:: cout oja.

Täisarvude tüübid

Täisarvu 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;

Ujukoma tüübid

Ujukoma- ja/või murdosa tüüpe esindavad sellised tüübid nagu float , double ja long double :

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

Andmetüüpide suurused

Ülaltoodud loendis on iga tüübi jaoks märgitud selle mälus olev suurus. Siiski tasub tähele panna, et kompilaatorite arendajad saavad ise valida tüüpide suurusepiirangud, lähtudes arvuti riistvara võimalustest. Standard määrab ainult minimaalsed väärtused, mis peaksid olema. Näiteks int ja lühikeste tüüpide puhul on minimaalne väärtus 16 bitti, pika tüübi puhul 32 bitti, 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 olema olla suurem kui kahekordne. Näiteks Windowsi all olev kompilaator g++ kasutab long double jaoks 12 baiti, samas kui Visual Studiosse sisseehitatud ja ka Windowsi all töötav kompilaator kasutab pika topeltarvu jaoks 8 baiti. See tähendab, et isegi sama platvormi piires võivad erinevad kompilaatorid läheneda mõne andmetüübi suurusele erineval viisil. Kuid üldiselt kasutatakse neid suurusi, mis on ülaltoodud andmetüüpide kirjeldamisel.

Siiski on olukordi, kus peate täpselt teadma konkreetse tüübi 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++-sse kompileerimisel:

suurus(arv) = 12

Samas on muutujate määratlemisel 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 annab selle reaga programmi kompileerimisel veateate, mis teatab, et väärtus -65535 ei ole allkirjastamata lühikese tüübi jaoks kehtivate väärtuste vahemikus ja see kärbitakse.

Visual Studios võib koostamine läbida vigadeta, kuid numbrimuutujaks seatakse 2, mille tulemuseks on -65535 teisendamine märgita lühiteks. See tähendab, et tulemus ei ole jällegi see, mida oodatakse. Muutuja väärtus on vaid bittide kogum mälus, mida tõlgendatakse vastavalt teatud 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 on väljendi tüüpi raske määrata. 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.

C-vormingus andmetüübid on andmete klass, mille väärtustel on sarnased omadused. Tüüp määrab mälus olevate andmete sisemise esituse. Kõige elementaarsemad andmetüübid on tõeväärtus, täisarv, ujukoma, string, osuti.

Dünaamilise tippimise korral seostatakse muutuja initsialiseerimise ajal tüübiga. Selgub, et koodi erinevates osades olev muutuja võib olla erinevat tüüpi. Dünaamilist tippimist toetavad Java Script, Python, Ruby, PHP.

Staatiline tippimine on dünaamilise tippimise vastand. Deklareerimisel saab muutuja tüübi, mis edaspidi ei muutu. Keeled C ja C++ on just sellised. See meetod on kõige mugavam keerulise koodi kirjutamiseks ja paljud vead kõrvaldatakse kompileerimisetapis.

Keeled jagunevad mitteametlikult tugevasti trükitud ja nõrgalt trükitud. Tugev tippimine tähendab, et kompilaator annab vea, kui oodatud ja tegelik tüüp ei ühti.

x = 1 + "2"; //viga - numbrile ei saa märgimärki lisada

Nõrga tippimise näide.

Tüübi vastavuse kontrolli teostab tüübiohutussüsteem. Tippimisviga tekib näiteks siis, kui proovite funktsioonina kasutada numbrit. On tüpiseerimata keeli. Erinevalt trükkimisest võimaldavad need teha iga objektiga mis tahes toiminguid.

Mälu klassid

Muutujatel, olenemata nende tüübist, on oma ulatus ja eluiga.

Mälu klassid:

• auto;
• staatiline;
• väline;
• Registreeri.

Kõik C muutujad on vaikimisi kohalikud. Neid saab kasutada ainult funktsiooni või ploki sees. Funktsiooni lõppedes nende väärtus hävib.

Staatiline muutuja on samuti lokaalne, kuid väljaspool oma plokki võib sellel olla erinev väärtus ja väärtus säilib funktsioonikutsete vahel.

Väline muutuja on globaalne. See on saadaval koodi mis tahes osas ja isegi mõnes teises failis.

Andmetüübi spetsifikaatorid C-s võib järgmistel juhtudel ära jätta.

1. Kõik ploki sees olevad muutujad ei ole muutujad; vastavalt sellele, kui seda konkreetset salvestusklassi kasutatakse, siis automaatset määrajat ei määrata.
2. Kõik väljaspool plokki või funktsiooni deklareeritud funktsioonid on vaikimisi globaalsed, seega on väline spetsifikaator valikuline.

Lihtsate tüüpide määramiseks on määratud int, char, float või topeltspetsifikaadid. Muutujaid saab asendada unsigned (unsigned), signed (signed), lühike, pikk, pikk pikk.

Vaikimisi on kõik numbrid allkirjastatud, nii et need võivad olla ainult positiivsete arvude vahemikus. Char-tüüpi muutuja defineerimiseks allkirjastatuna kirjutage signed char. Pikk, pikk pikk ja lühike näitavad, kui palju mäluruumi on salvestamiseks eraldatud. Suurim on pikk pikk, väikseim on lühike.

Char on C-s väikseim andmetüüp. Väärtuste salvestamiseks on eraldatud ainult 1 bait mälu. Märgi tüüpi muutujale määratakse tavaliselt märgid, harvemini numbrid. Tähemärkide väärtused on jutumärkides.

Tüüp int salvestab täisarvud, selle suurus pole defineeritud – see võtab sõltuvalt arvuti arhitektuurist kuni 4 baiti mälu.

Märgita muutuja selgesõnaline teisendamine on esitatud järgmiselt:

Implitsiitne näeb välja selline:

Ujuvad ja topeltmääratlevad numbrid punktiga. Ujukid on tähistatud kui -2,3 või 3,34. Kahekordset kasutatakse suurema täpsuse huvides – pärast kümnendkoha eraldajat määratakse rohkem numbreid. See tüüp võtab rohkem mäluruumi kui float.

Tühisuse väärtus on tühi. See määratleb funktsioonid, mis ei tagasta midagi. See spetsifikaator määrab meetodi argumentides tühja väärtuse. Osutajad, mis võivad võtta mis tahes andmetüüpi, on samuti määratletud kui tühised.

Boole'i ​​tüüp

Kasutatakse seisunditestides ja silmustes. Sellel on ainult kaks tähendust:

• tõsi;
• valetama.

Tõeväärtused saab teisendada int väärtuseks. Tõene võrdub ühega, väär on võrdne nulliga. Tüübi teisendamine toimub ainult booli ja int vahel, vastasel juhul tekitab kompilaator vea.

if (x) ( //Viga: "Tüüpi "int" ei saa kaudselt teisendada "booliks""

if (x != 0) // C# viis

Stringid ja massiivid

Massiivid on C-s keerulised andmetüübid. JS ei tööta stringidega samamoodi nagu Javascript või Ruby. C-s on kõik stringid märgiväärtuste elementide massiivid. Stringid lõpevad nullbaidiga "

Selles õppetükis vaatleme täisarvude andmetüüpe, nende väärtusvahemikke, jagamist ja ületäitumist: mis need on ja näiteid.

Täisarvude andmetüübid

täisarvu andmetüüp on tüüp, mille muutujad võivad sisaldada ainult täisarve (ilma murdosata, näiteks: -2, -1, 0, 1, 2). C++-l on kasutamiseks saadaval viis põhilist täisarvu tüüpi:

Märge: märgi tüüp on erijuhtum, mis on nii täisarv kui ka märgi andmetüüp. Sellest räägime lähemalt ühes järgmistest õppetundidest.

Peamine erinevus ülaltoodud täisarvutüüpide vahel on nende , mida suurem see on, seda rohkem väärtusi seda tüüpi muutuja suudab salvestada.

Täisarvuliste muutujate määratlemine

See juhtub nii:

char c; lühike int si; // kehtivad lühikesed s; // eelistatavalt int i; pikk intli; // kehtiv pikk l; // eelistatavalt pikk pikk int lli; // kehtiv pikk pikk ll; // eelistatud

Kuigi täisnimesid short int , long int ja long long int saab kasutada, on eelistatud nende lühendatud versioonid (ilma int ). Lisaks muudab int pidev lisamine koodi lugemise keeruliseks (lihtne muutujaga segi ajada).

Täisarvuliste andmetüüpide väärtusvahemikud ja märgid

Nagu te juba eelmisest õppetükist teate, võib n-bitisega muutuja salvestada 2n võimalikku väärtust. Aga mis need väärtused on? Need, mis on vahemikus. Vahemik on väärtused, millest konkreetne andmetüüp saab salvestada. Täisarvulise muutuja vahemiku määravad kaks tegurit: selle suurus (bittides) ja selle suurus märk(mis võib olla allkirjastatud või allkirjastamata).

allkirjastatud(märgiga) tähendab, et muutuja võib sisaldada nii positiivseid kui ka negatiivseid arve. Muutuja allkirjastatuks deklareerimiseks kasutage märksõna allkirjastatud:

märgiga c; allkirjastatud lühikesed püksid; allkirjastatud int i; signeeritud longl; allkirjastatud pikk pikk ll;

signeeritud char c ; allkirjastatud lühikesed püksid; allkirjastatud int i ; allkirjastatud pikk l ; allkirjastatud pikk pikk ll ;

Vaikimisi kirjutatakse allkirjastatud märksõna enne andmetüüpi.

Märgiga 1-baidise täisarvu muutuja väärtusvahemik on -128 kuni 127. Sellesse saab turvaliselt salvestada mis tahes väärtusi vahemikus -128 kuni 127 (kaasa arvatud).

Mõnel juhul võime ette teada, et negatiivseid numbreid programmis ei kasutata. See on väga levinud, kui kasutate muutujaid millegi koguse või suuruse salvestamiseks (näiteks ei saa teie pikkus või kaal olla negatiivne). täisarvu tüüp allkirjastamata(märgita) võib sisaldada ainult positiivseid numbreid. Muutuja like deklareerimiseks allkirjastamata, kasutage märksõna allkirjastamata:

märgita märk c; märgita lühikesed püksid; allkirjastamata int i; märgita pikk l; allkirjastamata pikk pikk ll;

märgita märk c ; märgita lühike s ; allkirjastamata int i ; signeerimata pikk l ; allkirjastamata pikk pikk ll ;

1-baidise märgita täisarvu muutuja väärtuste vahemik on 0 kuni 255.

Pange tähele, et muutuja märgita kuulutamine tähendab, et see ei saa sisaldada negatiivseid arve (ainult positiivseid).

Nüüd, kui mõistate erinevust allkirjastatud ja allkirjastamata vahel, vaatame erinevate andmetüüpide väärtusvahemikke.

Suurus/tüüp	Väärtuse vahemik
1 bait allkirjastatud	-128 kuni 127
1 bait allkirjastamata	0 kuni 255
2 baiti allkirjastatud	-32768 kuni 32767
2 baiti allkirjastamata	0 kuni 65535
4 baiti allkirjastatud	alates -2 147 483 648 kuni 2 147 483 647
4 baiti allkirjastamata	0 kuni 4 294 967 295
8 baiti allkirjastatud	alates -9 223 372 036 854 775 808 kuni 9 223 372 036 854 775 807
8 baiti allkirjastamata	0 kuni 18 446 744 073 709 551 615

Matemaatikute jaoks: n-bitise märgiga muutuja vahemik on -(2 n-1) kuni 2 n-1 -1. N-bitise märgita muutuja vahemik on 0 kuni (2n)-1. Mittematemaatikutele: kasutage tabelit 🙂

Algajad programmeerijad lähevad mõnikord segadusse allkirjastatud ja allkirjastamata muutujate vahel. Kuid on lihtne viis nende erinevuste meeldejätmiseks. Mis vahe on negatiivsel ja positiivsel arvul? Õige! Miinus ees. Kui miinust pole, on arv positiivne. Seetõttu tähendab märgiga täisarvu tüüp, et miinus võib esineda, s.t. numbrid võivad olla nii positiivsed kui ka negatiivsed. Märgita täisarvu tüüp tähendab, et ees olev miinus puudub täielikult, st. numbrid võivad olla ainult positiivsed.

Mis on vaikimisi: allkirjastatud või allkirjastamata?

Mis juhtub siis, kui deklareerime muutuja ilma allkirjastatud või allkirjastamata?

Kõik täisarvulised andmetüübid peale char on vaikimisi allkirjastatud. Märgi tüüp võib olla kas märgistatud või märgita (kuid tavaliselt allkirjastatud).

Enamasti allkirjastatud märksõna ei kirjutata (see on vaikimisi juba kasutusel), välja arvatud char tüüp (parem siinkohal täpsustada).

Programmeerijad üldiselt väldivad märgita täisarvu tüüpide kasutamist, kui see pole tingimata vajalik, kuna märgita muutujad on statistiliselt vigade suhtes tõenäolisemad kui märgiga muutujad.

Reegel: kasutage märgiga täisarvu tüüpe, selle asemel allkirjastamata.

Ülevool

Küsimus: "Mis juhtub, kui proovime kasutada väärtust, mis jääb väljapoole teatud andmetüübi väärtuste vahemikku?". Vastus: ülevool. Ülevool(Inglise) "ülevool") juhtub siis, kui bitid lähevad kaotsi, kuna muutujale ei ole nende salvestamiseks piisavalt mälu eraldatud.

Ülevoolu näited

Vaatleme märgita muutujat, mis koosneb 4 bitist. Selle muutuja sisse mahub kõik ülaltoodud tabelis loetletud kahendarvud.

"Aga mis juhtub, kui proovime määrata väärtuse, mis võtab rohkem kui 4 bitti?" Õige! Ülevool. Meie muutuja salvestab ainult 4 kõige vähem olulist (parempoolset) bitti, kõik ülejäänud lähevad kaotsi.

Näiteks kui proovime oma 4-bitisesse muutujasse panna arvu 21:

Kümnendsüsteem	Binaarsüsteem
21	10101

Arv 21 võtab 5 bitti (10101). Parempoolsed 4 bitti (0101) mahuvad muutujasse ja kõige vasakpoolsem bitt (1) läheb lihtsalt kaotsi. Need. meie muutuja sisaldab 0101, mis on võrdne 101-ga (eesolevat nulli ei võeta arvesse) ja see on number 5, mitte 21.

Märge: Arvude kahendarvust kümnendarvuks teisendamiseks ja vastupidi on eraldi õppetund, kus me kõike üksikasjalikult kaalume ja arutame.

Vaatame nüüd näidet koodis (lühike tüüp võtab 16 bitti):

#kaasa int main() ( märgita lühike x = 65535; // suurim väärtus, mida 16-bitine märgita muutuja saab salvestada std::cout<< "x was: " << x << std::endl; x = x + 1; // 65536 - это число больше максимально допустимого числа из диапазона допустимых значений. Следовательно, произойдёт переполнение, так как переменнная x не может хранить 17 бит std::cout << "x is now: " << x << std::endl; return 0; }

#kaasa int main() märgita lühike x = 65535; // suurim väärtus, mida 16-bitine märgita muutuja võib hoida std::cout<< "x was: " << x << std :: endl ; x = x + 1 // 65536 on arv, mis on suurem kui maksimaalne lubatud arv lubatud väärtuste vahemikus. Seetõttu tekib ületäitumine, kuna x ei saa salvestada 17 bitti. std::cout<< "x is now: " << x << std :: endl ; tagasi 0 ;

x oli: 65535
x on praegu: 0

Mis on juhtunud? Tekkis ületäitumine, kuna proovisime toppida midagi, mida ei saa x-i toppida.

Neile, kes soovivad rohkem teada: Arv 65 535 on binaarselt esitatud kui 1111 1111 1111 1111. 65 535 on suurim arv, mida 2-baidine (16-bitine) märgita täisarvuline muutuja saab salvestada, kuna see kasutab kõiki 16 bitti. Kui liidame 1, saame arvu 65536. Arv 65536 esitatakse kahendkoodina 1 0000 0000 0000 0000 ja võtab enda alla 17 bitti! Seetõttu kaob kõige olulisem bitt (mis on 1), samas kui kõik 16 paremal olevat bitti jäävad alles. Kombinatsioon 0000 0000 0000 0000 vastab kümnendarvule 0, mis on meie tulemus.

Samamoodi saame ülevoolu, kui kasutame arvu, mis on väiksem kui kehtivate väärtuste vahemiku miinimum:

#kaasa int main() ( märgita lühike x = 0; // väikseim väärtus, mida 2-baidine märgita muutuja võib sisaldada std::cout<< "x was: " << x << std::endl; x = x - 1; // переполнение! std::cout << "x is now: " << x << std::endl; return 0; }

#kaasa int main() märgita lühike x = 0 ; // väikseim väärtus, mida 2-baidine märgita muutuja võib hoida std::cout<< "x was: " << x << std :: endl ; x = x-1; // ülevool! std::cout<< "x is now: " << x << std :: endl ; tagasi 0 ;

Ülaltoodud programmi käivitamise tulemus on:

x oli: 0
x on praegu: 65535

Ületäitumine toob kaasa teabe kadumise ja see pole kunagi teretulnud. Kui on vähimgi kahtlus või vihje, et muutuja väärtus võib olla arv, mis jääb väljapoole kasutatava andmetüübi kehtivate väärtuste vahemikku – kasutage suuremat andmetüüpi!