namai  /  Kompiuteriai  /  Sveikųjų skaičių duomenų tipai, skirti 32 bitų procesoriui. Duomenų tipai ir kintamieji

Sveikųjų skaičių duomenų tipai, skirti 32 bitų procesoriui. Duomenų tipai ir kintamieji

Kompiuteriai
27.06.2020

Paskutinis atnaujinimas: 2017-11-13

Kaip ir daugelyje programavimo kalbų, C # turi savo duomenų tipų sistemą, kuri naudojama kintamiesiems kurti. Duomenų tipas apibrėžia vidinį duomenų atvaizdavimą, reikšmių rinkinį, kurį objektas gali atlikti, ir galiojančius veiksmus, kuriuos galima pritaikyti objektui.

C # kalba turi šiuos primityvius duomenų tipus:

    bool: teisinga arba klaidinga (bulio literalai). Atstovauja sistemos tipu System.Boolean

    Bool gyvas = tiesa; bool isDead = klaidinga;

    baitas: išsaugo sveikąjį skaičių nuo 0 iki 255 ir užima 1 baitą. Atstovauja sistemos tipu System.Byte

    1 baitas = 1; baitas bit2 = 102;

    sbyte: išsaugo sveikąjį skaičių nuo -128 iki 127 ir užima 1 baitą. Atstovauja sistemos tipu System.SByte

    Sbaitas bit1 = -101; sbyte bit2 = 102;

    trumpas: išsaugo sveikąjį skaičių nuo -32768 iki 32767 ir užima 2 baitus. Atstovauja sistemos tipu System.Int16

    Trumpas n1 = 1; trumpas n2 = 102;

    ushort: išsaugo sveikąjį skaičių nuo 0 iki 65535 ir užima 2 baitus. Atstovauja sistemos tipu System.UInt16

    Trumpas n1 = 1; trumpasis n2 = 102;

    int: išsaugo sveikąjį skaičių nuo -2147483648 iki 2147483647 ir užima 4 baitus. Atstovauja sistemos tipu System.Int32. Pagal numatytuosius nustatymus visi sveikieji skaitmenys reiškia int reikšmes:

    Int a = 10; int b = 0b101; // dvejetainė forma b = 5 int c = 0xFF; // šešioliktainė forma c = 255

    uint: išsaugo sveikąjį skaičių nuo 0 iki 4294967295 ir užima 4 baitus. Atstovauja sistemos tipu System.UInt32

    Uint a = 10; uint b = 0b101; uint c = 0xFF;

    ilgas: išsaugo sveikąjį skaičių nuo –9 223 372 036 854 775 808 iki 9 223 372 036 854 775 807 ir užima 8 baitus. Atstovauja sistemos tipu System.Int64

    Ilgas a = -10; ilgas b = 0b101; ilgas c = 0xFF;

    ulong: išsaugo sveikąjį skaičių nuo 0 iki 18 446 744 073 709 551 615 ir užima 8 baitus. Atstovauja sistemos tipu System.UInt64

    Ilgasis a = 10; ilgasis b = 0b101; ilgasis c = 0xFF;

    float: išsaugo slankiojo kablelio skaičių nuo -3,4 * 10 38 iki 3,4 * 10 38 ir užima 4 baitus. Atstovauja sistemos tipu System.Single

    dvigubas: išsaugo slankaus kablelio skaičių nuo ± 5,0 * 10 -324 iki ± 1,7 * 10 308 ir užima 8 baitus. Atstovauja sistemos tipu System.Double

    Dešimtainė: išsaugo trupmeninį dešimtainį skaičių. Jei naudojamas be kablelio, jo reikšmė yra nuo ± 1,0 * 10 -28 iki ± 7,9228 * 10 28, gali saugoti 28 skaitmenis po kablelio ir užima 16 baitų. Pateikiamas sistemos tipu System.Decimal

    char: išsaugo vieną Unicode simbolį ir užima 2 baitus. Atstovauja sistemos tipu System.Char. Simbolių raidės atitinka šį tipą:

    Char a = "A"; char b = "\ x5A"; char c = "\ u0420";

    eilutė: išsaugo Unicode simbolių rinkinį. Atstovauja sistemos tipu System.String. Šį tipą atitinka simbolių raidės.

    Styga labas = "Labas"; eilutės žodis = "pasaulis";

    objektas: gali saugoti bet kokio tipo duomenų reikšmę ir yra 4 baitai 32 bitų platformoje ir 8 baitai 64 bitų platformoje. Atstovauja sistemos tipu System.Object, kuris yra pagrindinis visų kitų .NET tipų ir klasių tipas.

    Objektas a = 22; objektas b = 3,14; objektas c = "sveikas kodas";

Pavyzdžiui, apibrėžkime kelis skirtingų tipų kintamuosius ir atspausdinkime jų reikšmes konsolėje:

Sistemos naudojimas; vardų sritis HelloApp (klasė Programa (static void Main (string args)) (stygos pavadinimas = "Tom"; int age = 33; bool isEmployed = false; dvigubas svoris = 78,65; Console.WriteLine ($ "Vardas: (vardas)"); Console.WriteLine ($ "Age: (amžius)"); Console.WriteLine ($ "Svoris: (svoris)"); Console.WriteLine ($ "Veikia: (isEmployed)");)))

Norėdami išvesti duomenis į konsolę, čia naudojama interpoliacija: prieš eilutę dedamas $ ženklas, o po to kintamųjų reikšmes galime įvesti į eilutę sulenktuose skliaustuose. Programos konsolės išvestis:

Vardas: Tomas Amžius: 33 Svoris: 78,65 Dirbo: Netiesa

Priesagų naudojimas

Priskirdami reikšmes, nepamirškite šios subtilybės: visi tikrieji literalai traktuojami kaip dvigubos reikšmės. Ir norėdami nurodyti, kad trupmeninis skaičius reiškia plūdinį arba dešimtainį tipą, prie pažodinio žodžio turite pridėti priesagą: F / f - plūduriuoti, o M / m - dešimtainį.

Taip pat visi sveikųjų skaičių literalai laikomi int reikšmėmis. Jei norite aiškiai nurodyti, kad sveikasis skaitmuo reiškia uint reikšmę, turite naudoti U / u priesagą, ilgą su priesaga L / l ir ulong su priesaga UL / ul:

Uint a = 10U; ilgas b = 20L; ilgis c = 30UL;

Naudojant sistemos tipus

Aukščiau, išvardijant visus pagrindinius duomenų tipus, buvo paminėtas kiekvieno sistemos tipas. Kadangi integruoto tipo pavadinimas iš esmės yra sistemos tipo santrumpa. Pavyzdžiui, šie kintamieji bus lygiaverčiai pagal tipą:

Int a = 4; Sistema.Int32 b = 4;

Netiesioginis spausdinimas

Anksčiau mes aiškiai nurodėme kintamųjų tipą, pavyzdžiui, int x; ... Ir kompiliatorius jau paleidimo metu žinojo, kad x saugo sveikąjį skaičių.

Tačiau galime naudoti ir netiesioginį spausdinimo modelį:

Var hello = "Pragaras pasauliui"; var c = 20; Console.WriteLine (c.GetType (). ToString ()); Console.WriteLine (labas.GetType (). ToString ());

Įvedant numanomą tekstą, vietoj duomenų tipo pavadinimo naudojamas raktinis žodis var. Tada kompiliavimo metu pats kompiliatorius nustato duomenų tipą pagal priskirtą reikšmę. Aukščiau pateiktame pavyzdyje buvo naudojama išraiška Console.WriteLine (c.GetType (). ToString ()); kuri leidžia išsiaiškinti numanomą kintamojo c tipą. Kadangi pagal numatytuosius nustatymus visos sveikųjų skaičių reikšmės laikomos int tipo, tai galiausiai kintamasis c bus tipo int arba System.Int32

Šie kintamieji yra panašūs į įprastus kintamuosius, tačiau jie turi tam tikrų apribojimų.

Pirma, negalime pirmiausia deklaruoti netiesiogiai įvesto kintamojo ir tada inicijuoti:

// šis kodas veikia in a; a = 20; // šis kodas neveikia var c; c = 20;

Antra, negalime nurodyti nulio kaip netiesiogiai įvesto kintamojo reikšmės:

// šis kodas neveikia var c = null;

Kadangi reikšmė yra nulinė, kompiliatorius negali nustatyti duomenų tipo.

dvigubas arba dešimtainis

Iš aukščiau pateikto duomenų tipų sąrašo akivaizdu, kad jei programoje norime naudoti skaičius iki 256, tai jiems saugoti galime naudoti baitų tipo kintamuosius. Naudodami dideles reikšmes galime imti tipus short, int, long. Tas pats pasakytina apie trupmeninius skaičius - paprastiems trupmeniniams skaičiams galite naudoti plūduriuojančią tipą, labai dideliems trupmeniniams skaičiams - dvigubą tipą. Dešimtainis tipas čia išsiskiria tuo, kad nepaisant didelio bitų gylio, palyginti su dvigubu tipu, dvigubas tipas gali saugoti didesnę reikšmę. Tačiau dešimtainėje reikšmėje gali būti iki 28 skaitmenų po kablelio, o dviguboje – 15–16 skaitmenų po kablelio.

Dešimtainė dažniau naudojama finansiniuose skaičiavimuose, o dviguba – matematiniuose veiksmuose. Bendrieji šių dviejų tipų skirtumai gali būti apibendrinti šioje lentelėje.

Sveikojo skaičiaus tipas (int)

Tipo dydis tarpt nėra apibrėžtas standarto, bet priklauso nuo kompiuterio ir kompiliatoriaus.

16 bitų procesoriui šio tipo reikšmėms skiriami 2 baitai,

32 bitams – 4 baitai.

Specifikatorius trumpas prieš tipo pavadinimą kompiliatoriui nurodo, kad numeriui turi būti skirti 2 baitai, neatsižvelgiant į procesoriaus bitą.

Specifikatorius ilgas reiškia, kad sveikojo skaičiaus reikšmė užims 4 baitus.

Taigi 16 bitų kompiuteryje atitikmenys yra int ir short int,

o 32 bitų atveju jis yra int ir long int.

Vidinis atstovavimas sveikųjų skaičių reikšmės – dvejetainis sveikasis skaičius. Kai naudojate specifikaciją pasirašė reikšmingiausias skaičiaus bitas interpretuojamas kaip pasirašytas (0 yra teigiamas skaičius, 1 yra neigiamas). Specifikatorius nepasirašytas leidžia pavaizduoti tik teigiamus skaičius, nes reikšmingiausias bitas yra traktuojamas kaip skaičiaus kodo dalis. Taigi, int reikšmių diapazonas priklauso nuo specifikacijų. Su IBM PC suderinamų kompiuterių sveikųjų skaičių verčių diapazonai su skirtingais specifikacijomis pateikiami lentelėje „Paprastų duomenų tipų verčių diapazonai“.

Pagal numatytuosius nustatymus visi sveikųjų skaičių tipai laikomi pasirašytais, tai yra, pasirašyto specifikatoriaus galima praleisti.

Programoje rastoms konstantoms pagal jų tipą priskiriami vienokie ar kitokie tipai. Jei dėl kokių nors priežasčių tai netinka programuotojui, galite aiškiai nurodyti reikiamą tipą naudodami priesagas L, l (ilgas) ir U, u (nepasirašytas). Pavyzdžiui, konstanta 32L bus ilgio tipo ir užims 4 baitus. Vienu metu galite naudoti priesagas L ir U, pavyzdžiui, 0x22UL arba 05Lu.

Pastaba. Tipai short int, long int, signed int ir unsigned int gali būti sutrumpintai atitinkamai trumpi, long, signed ir unsigned.

Simbolių tipas (char)

Simbolių tipo reikšmei priskiriamas baitų skaičius, kurio pakanka, kad tilptų bet kuris simbolių rinkinio simbolis tam tikram kompiuteriui, dėl kurio ir atsirado tipo pavadinimas. Paprastai tai yra 1 baitas. char tipas, kaip ir kiti sveikųjų skaičių tipai, gali būti pasirašytas arba nepasirašytas. Pasižymėtos reikšmės gali saugoti reikšmes diapazone nuo -128 iki 127. Naudojant nepaženklintą specifikatorių, reikšmės gali svyruoti nuo 0 iki 255. To pakanka, kad būtų išsaugotas bet koks simbolis 256 simbolių ASCII rinkinyje. Char vertės taip pat naudojamos sveikiesiems skaičiams saugoti.



Išplėstinis simbolių tipas (wchar_t)

A tipas wchar_t skirtas dirbti su simbolių rinkiniu, kuriam užkoduoti neužtenka 1 baito. Pavyzdžiui, Unicode. Šio tipo dydis priklauso nuo įgyvendinimo; dažniausiai atitinka tipą trumpas. Wchar_t tipo eilutės konstantos rašomos su L priešdėliu, pavyzdžiui, L „Vartai“.

Būlio tipas (bool)

Būlio reikšmės gali turėti tik reikšmes tiesa ir klaidinga kurie yra rezervuoti žodžiai. Vidinė klaidingos reikšmės forma yra 0 (nulis). Bet kuri kita reikšmė interpretuojama kaip tiesa. Konvertuojant į sveikojo skaičiaus tipą tiesa turi reikšmę 1.

Slankaus kablelio tipai (plūduriuojantis, dvigubas ir ilgas dvigubas)

C ++ standartas apibrėžia tris duomenų tipus tikrosioms reikšmėms saugoti: float, double ir long double.

Slankaus kablelio duomenų tipai atmintyje saugomi kitaip nei sveikųjų skaičių duomenų tipai. Vidinis tikrojo skaičiaus vaizdavimas susideda iš dviejų dalių - mantisa ir įsakymas.

Su IBM PC suderinamuose kompiuteriuose tokios reikšmės kaip plūdė užima 4 baitus, iš kurių skiriamas vienas dvejetainis skaitmuo po mantisos ženklu, 8 bitų pagal užsakymą ir 23 po mantisa. Mantisa yra skaičius, didesnis nei 1,0, bet mažesnis nei 2,0. Kadangi reikšmingiausias mantisos skaitmuo visada yra 1, jis neišsaugomas.

Dėl tokių vertybių kaip dvigubas, užimantys 8 baitus, tvarkai ir mantisai skiriami atitinkamai 11 ir 52 bitai. Mantisos ilgis lemia skaičiaus tikslumą, o užsakymo ilgis – diapazoną. Kaip matote iš lentelės įrašo pabaigoje, esant tiek pat baitų skaičiui, skirtų plūduriuojančioms ir ilgoms int reikšmėms, jų leistinų reikšmių diapazonai labai skiriasi. dėl vidinės pateikimo formos.

Specifikatorius ilgas prieš tipo pavadinimą dvigubai rodo, kad jo vertei skirta 10 baitų.

Pagal numatytuosius nustatymus slankiojo kablelio konstantos yra dvigubo tipo. Galite aiškiai nurodyti konstantos tipą naudodami priesagas F, f (plaukimas) ir L, l (ilgas).

Pavyzdžiui, konstanta 2E + 6L bus long double tipo, o konstanta 1.82f bus float tipo.

Rašydami programas, kurios yra universalios skirtingoms platformoms, negalite daryti prielaidų dėl tipo dydžio tarpt. Norėdami jį gauti, turite naudoti operacijos dydį, kurio rezultatas yra tipo dydis baitais.

Pavyzdžiui, operacinės sistemos MS-DOS atveju dydisof (int) bus 2, o Windows 98 arba OS / 2 - 4.

ANSI standartas nenurodo pagrindinių tipų verčių diapazonų, nustatomi tik jų dydžių santykiai, pavyzdžiui:

dydis (plūduriuoti) ≤ slzeof (dvigubas) ≤ dydis (ilgas dvigubas)
dydis (char) ≤ slzeof (trumpas) ≤ dydis (int) ≤ dydis (ilgas)

Pastaba. Mažiausios ir didžiausios leidžiamos sveikųjų skaičių vertės priklauso nuo įgyvendinimo ir yra išvardytos antraštės faile (), realių tipų charakteristikos – byloje (), taip pat klasės šablone numeric_limits

Tuščio tipo

Be aukščiau išvardytų, tuštumos tipas priklauso pagrindiniams kalbos tipams, tačiau šio tipo reikšmių rinkinys yra tuščias. Jis naudojamas apibrėžti funkcijas, kurios negrąžina reikšmės, nurodyti tuščią funkcijos argumentų sąrašą, kaip pagrindinį rodyklių tipą ir liejimo operacijose.

Įvedami įvairūs sveikųjų ir realiųjų tipų tipai, kurie skiriasi duomenų atvaizdavimo diapazonu ir tikslumu, kad programuotojas galėtų efektyviausiai išnaudoti konkrečios aparatinės įrangos galimybes, nes tipo pasirinkimas priklauso nuo skaičiavimų greičio ir atminties kiekis. Tačiau vieno tipo kompiuteriams optimizuota programa gali būti neperkeliama į kitas platformas, todėl apskritai reikėtų vengti priklausomybių nuo specifinių duomenų tipų charakteristikų.

A tipas Vertybių diapazonas Dydis (baitai)
bool tiesa ir netikra
pasirašytas char -128 … 127
nepasirašytas char 0 … 255
pasirašytas trumpas tarpt -32 768 … 32 767
nepasirašytas trumpas tarpt 0 … 65 535
pasirašė ilgai tarpt -2 147 483 648 … 2 147 483 647
nepasirašytas ilgas tarpt 0 … 4 294 967 295
plūdė 3,4e-38 ... 3,4e + 38
dvigubai 1.7e-308 ... 1.7C + 308
ilgas dvigubas 3.4e-4932 ... 3.4e + 4932

Programos struktūra

C ++ programa susideda iš funkcijas, aprašymai ir pirminio procesoriaus nurodymai... Viena iš funkcijų turi turėti pavadinimą pagrindinis... Programos vykdymas prasideda nuo pirmojo šios funkcijos sakinio. Paprasčiausias funkcijos apibrėžimas turi tokį formatą:

Paprastai funkcija naudojama reikšmei apskaičiuoti, todėl jos tipas nurodomas prieš funkcijos pavadinimą. Žemiau yra keletas svarbiausių funkcijų, kurias turite žinoti:

  • jei funkcija neturi grąžinti reikšmės, nurodomas galiojimo tipas:
  • funkcijos korpusas yra blokas, todėl yra uždengtas garbanotomis petnešomis;
  • funkcijos negali būti įdėtos;
  • kiekvienas teiginys baigiasi kabliataškiu (išskyrus sudėtinį teiginį).

Programos su funkcijomis main, fl ir f2 struktūros pavyzdys:

Programa gali būti sudaryta iš kelių moduliai(šaltinio failai).

Pastabos dėl įvesties / išvesties C ++

C ++ neturi integruoto įvesties / išvesties - tai daroma naudojant standartinėse bibliotekose esančias funkcijas, tipus ir objektus.

Naudojami du būdai: funkcijos, paveldėtos iš C kalbos, ir C ++ objektai.

Pagrindinės C stiliaus įvesties / išvesties funkcijos:

int scanf (const char * formatas, ...) // įvestis
int printf (const char * formatas, ...) // išvestis

Jie atlieka suformatuotą tam tikro skaičiaus reikšmių įvestį ir išvedimą pagal formato eilutę. Formato eilutėje yra simbolių, kurie nukopijuojami į srautą (į ekraną) išvestyje arba prašomi iš srauto (iš klaviatūros) įvedant, ir konversijos specifikacijos, prasidedančios % ženklu, kurios pakeičiamos konkrečiomis įvesties reikšmėmis. ir išvestis.

Pavyzdys programa, naudojanti C stiliaus įvesties / išvesties funkcijas:

#įtraukti
int main () (
int i;
printf ("Įveskite sveikąjį skaičių \ n");
scanf ("% d", & i);
printf ("Įvedėte skaičių% d, ačiū!", i);
grąžinti 0;
}

Pirmoji šios programos eilutė yra išankstinio procesoriaus direktyva, pagal kurią į programos tekstą įterpiamas antraštės failas, kuriame aprašomos programoje naudojamos įvesties / išvesties funkcijos (šiuo atveju kampiniai skliaustai yra kalbos elementas). Visos išankstinio procesoriaus direktyvos prasideda # ženklu.

Trečioji eilutė yra sveikojo skaičiaus kintamojo, pavadinto i, aprašymas.

Funkcija printf ketvirtoje eilutėje išspausdina raginimą „Įveskite sveikąjį skaičių“ ir tęsia į naują eilutę pagal \ n pabėgimo seką. Funkcija scanf įveda iš klaviatūros įvestą sveikąjį skaičių į kintamąjį i (& ženklas reiškia adreso gavimo operaciją), o kitame sakinyje ekrane rodoma nurodyta eilutė, konvertavimo specifikaciją pakeičiant šio skaičiaus reikšme.

Programa naudojant C ++ klasės biblioteką:

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

Antraštės faile yra I / O valdymo klasių rinkinio aprašymas. Jis apibrėžia standartinius srauto objektus cin klaviatūros įvestims ir cout rodymui, taip pat įdėjimo į srautą operacija< < и чтения из потока >>.

Galite naudoti abu I / O organizavimo būdus, tačiau nerekomenduojama jų maišyti toje pačioje programoje.

Duomenų tipai

Duomenų tipai turi ypatingą reikšmę C #, nes tai yra stipriai spausdinama kalba. Tai reiškia, kad visoms operacijoms taikomas griežtas kompiliatoriaus tipo atitikimas, o netinkamos operacijos nėra kompiliuojamos. Todėl stiprus tipo tikrinimas padeda pašalinti klaidas ir pagerinti programų patikimumą. Norint patikrinti tipą, visi kintamieji, išraiškos ir reikšmės turi būti tam tikro tipo. Šioje programavimo kalboje apskritai nėra tokio dalyko kaip „be tipo“ kintamasis. Be to, nuo reikšmės tipo priklauso, kokias operacijas su ja galima atlikti. Vienam duomenų tipui leidžiama operacija gali būti netinkama kitam duomenų tipui.

Yra dvi bendros C # įtaisytųjų duomenų tipų kategorijos: vertės tipai ir nuorodų tipai... Jie skiriasi kintamojo turiniu. Konceptualiai skirtumas tarp šių dviejų yra tas, kad vertės tipas saugo duomenis tiesiogiai, o nuorodos tipas saugo nuorodą į reikšmę.

Šie tipai saugomi skirtingose ​​atminties vietose: reikšmių tipai saugomi srityje, vadinamoje krūva, o nuorodų tipai – srityje, vadinamoje valdoma krūva.

Pažiūrėkime vertės tipai.

Sveikųjų skaičių tipai

C # apibrėžia devynis sveikųjų skaičių tipus: char, baitas, sbyte, short, ushort, int, uint, long ir ulong... Tačiau char tipas daugiausia naudojamas simboliams pavaizduoti, todėl yra nagrinėjamas atskirai. Kiti aštuoni sveikųjų skaičių tipai skirti skaitiniams skaičiavimams. Jų skaičių vaizdavimo diapazonas ir bitų gylis yra pateikti žemiau:

Sveikųjų skaičių tipai C #
A tipas CTS tipas Bitelio gylis diapazonas
baitas System.Byte 8 0:255
sbyte System.SByte 8 -128:127
trumpas Sistema.Int16 16 -32768: 32767
trumpas Sistema.UInt16 16 0: 65535
tarpt Sistema.Int32 32 -2147483648: 2147483647
uint Sistema.UInt32 32 0: 4294967295
ilgas Sistema.Int64 64 -9223372036854775808: 9223372036854775807
ulong Sistema.UInt64 64 0: 18446744073709551615

Kaip matote iš aukščiau esančios lentelės, C # apibrėžia abu skirtingų sveikųjų skaičių variantus, pasirašytus ir nepasirašytus. Ženkliniai sveikųjų skaičių tipai skiriasi nuo neženklių atitikmenų tuo, kaip jie interpretuoja reikšmingiausią sveikojo skaičiaus bitą. Pavyzdžiui, jei programoje nurodyta sveikojo skaičiaus reikšmė su ženklu, C # kompiliatorius generuoja kodą, kuris kaip ženklo vėliavėlę naudoja reikšmingiausią sveikojo skaičiaus bitą. Skaičius laikomas teigiamu, jei ženklo vėliavėlė yra 0, ir neigiama, jei ji yra 1.

Neigiami skaičiai beveik visada pateikiami dviejų komplemento metodu, kai visi neigiamo skaičiaus dvejetainiai skaitmenys pirmiausia apverčiami, o tada prie to skaičiaus pridedamas 1.

Turbūt labiausiai paplitęs sveikųjų skaičių tipas programuojant yra int tipo... Int tipo kintamieji dažnai naudojami kilpos valdymui, masyvo indeksavimui ir bendriesiems matematiniams skaičiavimams. Kai reikalinga sveikojo skaičiaus reikšmė su didesniu skaičių atvaizdavimo diapazonu nei int tipo, yra keletas kitų sveikųjų skaičių tipų.

Taigi, jei vertę reikia išsaugoti nepasirašytą, galite ją pasirinkti uint tipas, didelėms pasirašytoms vertėms - ilgas tipas, o didelėms beženklėms reikšmėms – tipas ulong... Pavyzdžiui, žemiau pateikta programa, kuri apskaičiuoja atstumą nuo Žemės iki Saulės centimetrais. Norėdami išsaugoti tokią didelę reikšmę, jis naudoja ilgo tipo kintamąjį:

Sistemos naudojimas; naudojant System.Collections.Generic; naudojant System.Linq; naudojant System.Text; vardų sritis ConsoleApplication1 (klasė Programa (static void Main (string args)) (ilgas rezultatas; const long km = 149800000; // atstumas km.result = km * 1000 * 100; Console.WriteLine (rezultatas); Console.ReadLine (); )))

Visiems sveikiesiems kintamiesiems gali būti priskirtas dešimtainis arba šešioliktainis žymėjimas. Pastaruoju atveju būtinas 0x priešdėlis:

Ilgas x = 0x12ab;

Jei yra kokių nors neaiškumų, ar sveikojo skaičiaus reikšmė yra int, uint, long ar ulong tipo, tada numatytas priimtas int. Norėdami aiškiai nurodyti, kurio kito sveikojo skaičiaus tipas turi turėti reikšmę, prie skaičiaus galite pridėti šiuos simbolius:

Uint ui = 1234U; ilgas l = 1234L; ulong ul = 1234UL;

U ir L taip pat galima rašyti mažosiomis raidėmis, nors mažąsias L galima lengvai supainioti su 1 (viena).

Slankaus kablelio tipai

Slankaus kablelio tipai leidžia vaizduoti skaičius su trupmenine dalimi. Yra du slankaus kablelio duomenų tipai C #: plūdė ir dvigubai... Jie atitinkamai reiškia vieno tikslumo ir dvigubo tikslumo skaitines reikšmes. Taigi, plūduriuojančio tipo talpa yra 32 bitai, o tai maždaug atitinka skaičių vaizdavimo diapazoną nuo 5E-45 iki 3,4E + 38. O dvigubo tipo bitų gylis yra 64 bitai, o tai maždaug atitinka skaičių vaizdavimo diapazoną nuo 5E-324 iki 1,7E + 308.

Slankiųjų duomenų tipas skirtas mažesnėms slankiojo kablelio reikšmėms, kurioms reikalingas mažesnis tikslumas. Dvigubas duomenų tipas yra didesnis nei plūduriuojantis ir siūlo didesnį tikslumą (15 bitų).

Jei šaltinio kode yra užkoduota ne sveikojo skaičiaus reikšmė (pavyzdžiui, 12.3), tada kompiliatorius paprastai daro prielaidą, kad yra numanoma dviguba reikšmė. Jei reikšmę reikia nurodyti kaip plūduriuojančią reikšmę, prie jos turite pridėti F (arba f):

Plūdės f = 12,3F;

Dešimtainis duomenų tipas

Taip pat pateikiamas dešimtainis tipas, skirtas didelio tikslumo slankiojo kablelio skaičiams pateikti. dešimtainis, kuris skirtas naudoti finansiniams skaičiavimams. Šis tipas yra 128 bitų pločio ir reiškia skaitines reikšmes nuo 1E-28 iki 7,9E + 28. Tikriausiai žinote, kad dešimtainio apvalinimo klaidos yra dažnos įprastoje slankiojo kablelio aritmetikoje. Šios klaidos pašalinamos naudojant dešimtainį tipą, kuris gali reikšti skaičius iki 28 (o kartais ir 29) po kablelio. Kadangi šis duomenų tipas gali pateikti dešimtaines reikšmes be apvalinimo klaidų, jis ypač naudingas atliekant finansinius skaičiavimus:

Sistemos naudojimas; naudojant System.Collections.Generic; naudojant System.Linq; naudojant System.Text; vardų sritis ConsoleApplication1 (klasė Programa (static void Main (string args)) (// *** Kapitalo investicijų kainos apskaičiavimas su *** // *** fiksuota grąžos norma *** dešimtainiai pinigai, procentai; int i; const baitų metai = 15 ; pinigai = 1000,0 m; procentai = 0,045 m; (i = 1; i

Šios programos rezultatas bus:

Simboliai

C # simboliai pavaizduoti ne 8 bitų kodu, kaip daugelyje kitų programavimo kalbų, tokių kaip C ++, o 16 bitų kodu, vadinamu unikodas... „Unicode“ simbolių rinkinys yra toks platus, kad apima beveik visų natūralių pasaulio kalbų simbolius. Nors daugeliui natūralių kalbų, įskaitant anglų, prancūzų ir vokiečių, būdingos santykinai mažos abėcėlės, daugelyje kitų kalbų, pavyzdžiui, kinų, naudojami gana dideli simbolių rinkiniai, kurių negalima pavaizduoti 8 bitų kodu. Norėdami įveikti šį apribojimą, C # apibrėžia char tipo reiškia nepasirašytas 16 bitų reikšmes nuo 0 iki 65535. Tačiau standartinis 8 bitų ASCII simbolių rinkinys yra Unikodo poaibis nuo 0 iki 127. Todėl ASCII simboliai vis dar galioja C # ...

Šiame skyriuje apžvelgsime pagrindinius duomenų tipus C ++, šie duomenų tipai taip pat vadinami integruotais duomenų tipais. C ++ programavimo kalba yra išplečiama programavimo kalba. Išplečiamasis reiškia, kad be integruotų duomenų tipų galite sukurti savo duomenų tipus. Todėl C ++ yra daugybė duomenų tipų. Mes išnagrinėsime tik pagrindinius.

1 lentelė – C ++ duomenų tipai
A tipas baitas Priimtų verčių diapazonas

sveikasis (bulio) duomenų tipas
bool 1 0 / 255

sveikojo skaičiaus (simbolių) duomenų tipas
char 1 0 / 255

sveikųjų skaičių duomenų tipai
trumpas tarpt 2 -32 768 / 32 767
nepasirašytas trumpas tarpt 2 0 / 65 535
tarpt 4
nepasirašytas tarpt 4 0 / 4 294 967 295
ilgas tarpt 4 -2 147 483 648 / 2 147 483 647
nepasirašytas ilgas tarpt 4 0 / 4 294 967 295

slankiojo kablelio duomenų tipai
plūdė 4 -2 147 483 648.0 / 2 147 483 647.0
ilga plūdė 8
dvigubai 8 -9 223 372 036 854 775 808 .0 / 9 223 372 036 854 775 807.0

1 lentelėje parodyti pagrindiniai duomenų tipai C ++. Visa lentelė suskirstyta į tris stulpelius. Pirmas stulpelis nurodo rezervuotą žodį, kuris apibrėžs savo duomenų tipą. Antrame stulpelyje nurodomas baitų, skirtų kintamajam su atitinkamu duomenų tipu, skaičius. Trečiame stulpelyje rodomas galiojančių verčių diapazonas. Atminkite, kad lentelėje visi duomenų tipai rūšiuojami nuo mažiausio iki didžiausio.

Bool duomenų tipas

Pirmasis lentelėje yra bool duomenų tipas — sveikojo skaičiaus duomenų tipas, nes galiojančių reikšmių diapazonas yra sveikieji skaičiai nuo 0 iki 255. Bet kaip jau pastebėjote, tai rašoma skliausteliuose – loginis duomenų tipas, ir tai taip pat tiesa. Nes bool naudojamas tik loginių išraiškų rezultatams saugoti. Būlio išraiška gali turėti vieną iš dviejų rezultatų – teisingą arba klaidingą. tiesa – jei loginė išraiška teisinga, false – jei loginė išraiška klaidinga.

Tačiau kadangi loginio duomenų tipo galiojančių verčių diapazonas yra nuo 0 iki 255, reikėjo kažkaip susieti šį diapazoną su loginėmis konstantomis teisinga ir klaidinga, apibrėžta programavimo kalboje. Taigi konstanta tiesa yra lygi visiems skaičiams nuo 1 iki 255 imtinai, o konstanta false lygi tik vienam sveikajam skaičiui – 0. Apsvarstykite programą, naudojančią bool duomenų tipą.

// data_type.cpp: apibrėžia konsolės programos įėjimo tašką. #include "stdafx.h" #include naudojant vardų erdvę std; int main (int argc, char * argv) (bool boolean = 25; // bool tipo kintamasis pavadintas boolean if (bulio) // if sakinio sąlyga cout<< "true = " << boolean << endl; // выполнится в случае истинности условия else cout << "false = " << boolean << endl; // выполнится в случае, если условие ложно system("pause"); return 0; }

V 9 eilutėdeklaruojamas tipo kintamasis bool kuri inicijuojama į 25. Teoriškai po9 eilutė, loginiu kintamuoju jame turėtų būti skaičius 25, bet iš tikrųjų šiame kintamajame yra skaičius 1. Kaip jau sakiau, skaičius 0 yra klaidinga reikšmė, skaičius 1 yra tikroji reikšmė. Esmė ta, kad kintamajame patinka bool gali būti dvi reikšmės - 0 (klaidinga) arba 1 (teisinga). Tuo tarpu pagal duomenų tipą bool skiriamas visas baitas, o tai reiškia, kad tipo kintamasis bool gali būti skaičiai nuo 0 iki 255. Norint nustatyti klaidingas ir tikras vertes, reikia tik dviejų reikšmių, 0 ir 1. Kyla klausimas: "Kam yra kitos 253 reikšmės?"

Remdamiesi šia situacija, sutikome naudoti skaičius nuo 2 iki 255 kaip lygiaverčius skaičiui 1, tai yra tiesa. Štai kodėl loginiame kintamajame yra skaičius 25, o ne 1. In 10-13 eilutės deklaruota, kuri kontrolę perduoda operatoriui 11 eilutė, jei sąlyga teisinga, o operatorius yra 13 eilutė jei sąlyga klaidinga. Programos rezultatas parodytas 1 pav.

Tiesa = 1 Norėdami tęsti, paspauskite bet kurį klavišą. ... ...

1 pav. „Bool“ duomenų tipas

Char duomenų tipas

Duomenų tipas char yra sveikųjų skaičių duomenų tipas, naudojamas simboliams pavaizduoti. Tai reiškia, kad kiekvienas simbolis atitinka tam tikrą skaičių iš diapazono. Duomenų tipas char taip pat vadinamas simbolių duomenų tipu, nes grafinis simbolių atvaizdavimas C ++ yra įmanomas dėl char. Norėdami pavaizduoti simbolius C ++, char duomenų tipui skiriamas vienas baitas, viename baite - 8 bitai, tada du padidiname iki 8 laipsnio ir gauname reikšmę 256 - simbolių, kuriuos galima užkoduoti, skaičių. Taigi, naudodami duomenų tipą char, galite rodyti bet kurį iš 256 simbolių. Visi užkoduoti simboliai pavaizduoti.

ASCII (iš angliško Amerikos standartinio informacijos mainų kodo) yra Amerikos standartinis informacijos mainų kodas.

Apsvarstykite programą, naudojančią char duomenų tipą.

// symbols.cpp: apibrėžia konsolės programos įėjimo tašką. #include "stdafx.h" #include naudojant vardų erdvę std; int main (int argc, char * argv) (char simbolis = "a"; // char tipo kintamojo deklaravimas ir jo inicijavimas simboliu "a" cout<< "symbol = " << symbol << endl; // печать символа, содержащегося в переменной symbol char string = "сайт"; // объявление символьного массива (строки) cout << "string = " << string << endl; // печать строки system("pause"); return 0; }

Taigi į 9 eilutėdeklaruojamas kintamasis su pavadinimu simbolis , jam priskiriama simbolio reikšmė"a" ( ASCII kodas). V 10 eilutė cout operatorius išspausdina kintamajame esantį simbolį simbolis. V 11 eilutėpaskelbė eilučių masyvą pavadinimu styga , o masyvo dydis nustatomas netiesiogiai. Eilutė saugoma eilučių masyve"svetainė" ... Atkreipkite dėmesį, kad kai saugojome simbolį į kintamąjį kaip char , tada po lygybės ženklo dedame pavienes kabutes, kuriose įrašėme simbolį. Inicijuojant eilučių masyvą tam tikra eilute, po lygybės ženklo dedamos dvigubos kabutės, kuriose rašoma tam tikra eilutė. Kaip ir įprastas simbolis, eilutės išvedamos naudojant operatorių cout, 12 eilutė... Programos rezultatas parodytas 2 pav.

Simbolis = eilutė = svetainė Norėdami tęsti, paspauskite bet kurį klavišą. ... ...

2 pav. Duomenų tipo simbolis

Sveikųjų skaičių duomenų tipai

Skaičiams pavaizduoti naudojami sveikųjų skaičių duomenų tipai. 1 lentelėje yra šeši iš jų: short int, unsigned short int, int, unsigned int, long int, unsigned long int . Visi jie turi savo užimtos atminties dydį ir priimtinų verčių diapazoną. Priklausomai nuo kompiliatoriaus, užimtos atminties dydis ir priimtinų reikšmių diapazonas gali skirtis. 1 lentelėje pateikiami visi MVS2010 kompiliatoriaus priimtinų verčių diapazonai ir užimtos atminties dydžiai. Be to, visi duomenų tipai 1 lentelėje yra išdėstyti didėjančia tvarka pagal užimtos atminties dydį ir priimtų reikšmių diapazoną. Priimtų reikšmių diapazonas vienaip ar kitaip priklauso nuo užimtos atminties dydžio. Atitinkamai, kuo didesnis užimtos atminties dydis, tuo didesnis priimamų reikšmių diapazonas. Taip pat keičiasi priimtų reikšmių diapazonas, jei duomenų tipas deklaruojamas su priešdėliu nepasirašytas - nepasirašytas. Nepasirašytas priešdėlis reiškia, kad duomenų tipas negali saugoti pasirašytų reikšmių, tada teigiamų reikšmių diapazonas padvigubinamas, pavyzdžiui, duomenų tipai short int ir unsigned short int.

Sveikųjų skaičių duomenų tipo priešdėliai:

trumpas — priešdėlis sutrumpina duomenų tipą, kuriam jis taikomas, sumažindamas užimtos atminties dydį;

ilgas — priešdėlis pailgina duomenų tipą, kuriam jis taikomas, padidindamas užimtos atminties dydį;

nepasirašytas - priešdėlis padvigubina teigiamų reikšmių diapazoną, o neigiamų verčių diapazonas negali būti saugomas šiame duomenų tipe.

Taigi, iš esmės, turime vieną sveikųjų skaičių tipą, skirtą sveikiesiems skaičiams pavaizduoti – tai yra int duomenų tipas. Dėl trumpų, ilgų, be ženklų priešdėlių atsiranda tam tikra int duomenų tipų įvairovė, kuri skiriasi užimtos atminties dydžiu ir (ar) priimtų reikšmių diapazonu.

Slankaus kablelio duomenų tipai

C ++ yra du slankiojo kablelio duomenų tipai: float ir double. Slankaus kablelio duomenų tipai yra skirti saugoti slankiojo kablelio skaičius. Slankiųjų ir dvigubų duomenų tipai gali saugoti tiek teigiamus, tiek neigiamus slankiojo kablelio skaičius. Slankiojo tipo duomenų atminties dydis yra du kartus mažesnis nei dvigubo tipo duomenų, o tai reiškia, kad priimtų reikšmių diapazonas taip pat yra mažesnis. Jei plūduriuojančių duomenų tipas deklaruojamas su ilgu priešdėliu, tada priimtų reikšmių diapazonas taps lygus dvigubo duomenų tipo priimtų verčių diapazonui. Iš esmės slankiojo kablelio duomenų tipai reikalingi norint išspręsti didelio skaičiavimo tikslumo problemas, pavyzdžiui, pinigų operacijas.

Taigi, mes aptarėme pagrindinius dalykus, susijusius su pagrindiniais duomenų tipais C ++. Belieka tik parodyti, iš kur atsirado visi šie priimtinų verčių diapazonai ir užimtos atminties dydis. Ir tam mes sukursime programą, kuri apskaičiuos pagrindines visų aukščiau aptartų duomenų tipų charakteristikas.

// data_types.cpp: apibrėžia konsolės programos įėjimo tašką. #include "stdafx.h" #include // Įvesties / išvesties manipuliavimo biblioteka #include // matematinių funkcijų antraštės failas #include naudojant vardų erdvę std; int main (int argc, char * argv) (cout<< " data type " << "byte" << " " << " max value "<< endl // stulpelių antraštės <<"bool = " << sizeof(bool) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных bool*/ << (pow(2,sizeof(bool) * 8.0) - 1) << endl << "char = " << sizeof(char) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных char*/ << (pow(2,sizeof(char) * 8.0) - 1) << endl << "short int = " << sizeof(short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных short int*/ << (pow(2,sizeof(short int) * 8.0 - 1) - 1) << endl << "unsigned short int = " << sizeof(unsigned short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned short int*/ << (pow(2,sizeof(unsigned short int) * 8.0) - 1) << endl << "int = " << sizeof(int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных int*/ << (pow(2,sizeof(int) * 8.0 - 1) - 1) << endl << "unsigned int = " << sizeof(unsigned int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned int*/ << (pow(2,sizeof(unsigned int) * 8.0) - 1) << endl << "long int = " << sizeof(long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long int*/ << (pow(2,sizeof(long int) * 8.0 - 1) - 1) << endl << "unsigned long int = " << sizeof(unsigned long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных undigned long int*/ << (pow(2,sizeof(unsigned long int) * 8.0) - 1) << endl << "float = " << sizeof(float) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных float*/ << (pow(2,sizeof(float) * 8.0 - 1) - 1) << endl << "double = " << sizeof(double) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных double*/ << (pow(2,sizeof(double) * 8.0 - 1) - 1) << endl; system("pause"); return 0; }

Ši programa sukurta taip, kad galėtumėte peržiūrėti savo sistemos duomenų tipų charakteristikas. Kodo suprasti neverta, nes programa naudoja valdymo operatorius, kurių greičiausiai dar nežinote. Norėdami paviršutiniškai susipažinti su programos kodu, toliau paaiškinsiu kai kuriuos dalykus. operatorius dydis () apskaičiuoja duomenų tipui arba kintamajam skirtų baitų skaičių. Funkcija pow (x, y) pakelia prasmę x iki y laipsnio , ši funkcija pasiekiama antraštės faile ... Fiksuoti ir nustatyti tikslumo () manipuliatoriai galima iš antraštės failo ... Pirmasis yra fiksuotas , siunčia vertes fiksuota forma į išvesties srautą. Manipuliatorius setprecision (n) rodo n po kablelio. Didžiausia tam tikro tipo duomenų vertė apskaičiuojama pagal šią formulę:

Max_val_type = 2 ^ (b * 8 - 1) - 1; // duomenų tipams su neigiamais ir teigiamais skaičiais // kur b yra baitų, skirtų atmintyje kintamajam su šiuo duomenų tipu, skaičius // padauginkite iš 8, nes viename baite yra 8 bitai // skliausteliuose atimkite 1 , nes teigiamų ir neigiamų verčių diapazono skaičiai turi būti sumažinti per pusę // pabaigoje atimkite 1, nes skaičių diapazonas prasideda nuo nulio // duomenų tipai su priešdėliu be ženklo max_val_type = 2 ^ (b * 8) - 1 ; // tik duomenų tipams su teigiamais skaičiais

Programos pavyzdį galima pamatyti 3 paveiksle. Pirmame stulpelyje rodomi pagrindiniai duomenų tipai C ++, antrame stulpelyje yra kiekvienam duomenų tipui priskirtos atminties dydis, o trečiame stulpelyje nurodoma didžiausia atitinkamų duomenų reikšmė. tipas gali turėti. Mažiausia vertė randama taip pat, kaip ir didžiausia. Duomenų tipams, kurių priešdėlis nepasirašytas, mažiausia reikšmė yra 0.

Duomenų tipas baitų Max vertė bool = 1 255.00 char = 1 255.00 trumpas int = 2 32.767,00 nepasirašytos trumpas int = 2 65.535,00 int = 4 2147483647.00 unsigned int = 4 4294967295.00 ilgai int = 4 2147483647,00 nepasirašytos ilgai int = 4 4294967295,00 plūdės = 4 2147483647,00 dviviečiai = 8 9223372036854775808.00 Norėdami tęsti, paspauskite bet kurį klavišą. ... ...

3 pav. – C ++ duomenų tipai

Jei, pavyzdžiui, short int tipo kintamajam priskiriama reikšmė 33000, bitų tinklelis persipildys, nes didžiausia trumpojo int tipo kintamojo reikšmė yra 32767. Tai yra, kintamajame bus saugoma kita reikšmė. tipo short int, greičiausiai jis bus neigiamas. Kadangi palietėme int duomenų tipą, verta paminėti, kad galite praleisti raktinį žodį int ir parašyti, pavyzdžiui, trumpai. Kompiliatorius interpretuos šį žymėjimą kaip trumpą int. Tas pats pasakytina apie ilgus ir nepasirašytus priešdėlius. Pavyzdžiui:

// duomenų tipo trumpinys int short a1; // toks pat kaip trumpas int long a1; // toks pat kaip ir ilgas int nepasirašytas a1; // tas pats kaip unsigned int unsigned short a1; // toks pat kaip nepasirašytas trumpasis tarpt

Žymos: C kintamieji. char, int, besigned, long, long long, float, double, long double, long float, leksinė apimtis. Kintamosios deklaracijos. Matomumo sritis. Kintamųjų inicijavimas. Kintamųjų pavadinimai. Eksponentinė forma.

Kintamieji

Kintamieji naudojami reikšmėms saugoti (sic!). Kintamasis apibūdinamas jo tipu ir pavadinimu. Pradėkime nuo pavadinimo. C kalboje kintamasis gali prasidėti apatiniu brūkšniu arba raide, bet ne skaičiumi. Kintamąjį gali sudaryti angliški simboliai, skaičiai ir apatinis brūkšnys. Kintamasis neturi sutapti su raktiniais žodžiais (tai yra specialūs žodžiai, naudojami kaip valdymo struktūros, tipams apibrėžti ir pan.)

automatinis dvigubai tarpt struktūra
pertrauka Kitas ilgas jungiklis
Registruotis typedef char išorinis
grąžinti tuštuma atvejis plūdė
nepasirašytas numatytas dėl pasirašė
sąjunga daryti jeigu dydis
nepastovios Tęsti enum trumpas
kol eilutę
Taip pat, pavyzdžiui, keletas kitų žodžių, būdingų šiai kompiliatoriaus versijai toli, šalia, mažas, didelis, asm, asm_ ir tt

Pavyzdžiui, teisingi identifikatoriai yra
a, _, _1_, Sarkasm, a_long_variable, aLongVariable, var19, defaultX, char_type
neištikimas
1a, $ vertė, a-ilgoji vertė, trumpoji

C yra didžiosios ir mažosios raidės. Kintamieji, pavadinti a ir A, arba pabaiga ir END, arba perfectDark ir PerfectDarK yra skirtingi kintamieji.

Kintamieji tipai

Kintamojo tipas nustato

  • 1) Kintamojo dydis baitais (kiek baitų atminties kompiuteris skirs reikšmei išsaugoti)
  • 2) Kintamojo atvaizdavimas atmintyje (kaip dvejetainėje formoje bitai bus skiriamoje atminties srityje).
Yra keletas pagrindinių tipų si. Padalinkime juos į dvi grupes – sveikuosius skaičius ir slankiojo kablelio skaičius.

Visas

  • char- dydis yra 1 baitas. Yra visada! Tai reikia atsiminti.
  • trumpas- dydis 2 baitai
  • tarpt- dydis 4 baitai
  • ilgas- dydis 4 baitai
  • ilgas ilgas- dydis 8 baitai.
Čia reikėtų padaryti pastabą. C kintamųjų dydis nėra aiškiai apibrėžtas kaip dydis baitais. Standartas tai tik nurodo

char<= short <= int <= long <= long long

Aukščiau pateiktos reikšmės būdingos VC2012 kompiliatoriui 32 bitų įrenginyje. Taigi, jei jūsų programa priklauso nuo kintamojo dydžio, nepatingėkite išsiaiškinti jo dydžio.

Dabar apibrėžkime didžiausią ir mažiausią skaičių, kurį gali saugoti kiekvieno tipo kintamasis. Skaičiai gali būti teigiami arba neigiami. Neigiami skaičiai naudoja vieną bitą ženklui išsaugoti. Kartais ženklas yra būtinas (pavyzdžiui, išsaugome banko sąskaitą, temperatūrą, koordinates ir pan.), o kartais nebūtina (svoris, masyvo dydis, žmogaus amžius ir pan.). Tam C naudoja pasirašytą ir nepasirašytą modifikatorių. unsigned char - visi 8 bitai skaičiui, iš viso turime skaičių rinkinį nuo 00000000 iki 11111111 dvejetaine forma, tai yra nuo 0 iki 255 signed char nuo -128 iki 128. C kalboje kintamieji pasirašomi pagal nutylėjimą . Todėl rašymas char ir signed char yra lygiaverčiai.

Skirtukas. 1 Sveikųjų skaičių tipų dydis si.
A tipas Dydis, baitai Minimali vertė Didžiausia vertė
nepasirašytas char 1 0 255
pasirašytas char
(char)		 1 -128 127
nepasirašytas trumpas 2 0 65535
pasirašė trumpai
(trumpas)		 2 -32768 32767
nepasirašytas tarpt
(nepasirašytas)		 4 0 4294967296
pasirašė tarpt
(int)		 4 -2147483648 2147483647
nepasirašytas ilgas 4 0 4294967296
pasirašė ilgai
(ilgas)		 4 -2147483648 2147483647
nepasirašytas ilgas ilgas 8 0 18446744073709551615
pasirašė ilgai ilgai
(ilgai ilgas)		 8 -9223372036854775808 9223372036854775807

dydis

C turi operatorių, leidžiantį gauti kintamojo dydį baitais. sizeof yra kintamasis arba dydis (kintamasis) arba sizeof (tipas). Būtent tai yra operatorius, nes funkcija negali gauti informacijos apie tipų dydį vykdymo metu. Parašykime nedidelę programą kintamųjų dydžiams patikrinti.

#įtraukti #įtraukti int main () (char c; short s; int i; long l; long long L; // Iškviesti sizeof kaip "funkciją" printf ("sizeof (char) =% d \ n", sizeof (c)); printf ("dydis (trumpas) =% d \ n", dydis (s)); printf ("dydis (int) =% d \ n", dydis (i)); printf ("dydis (ilgas) =% d" \ n ", sizeof (l)); printf (" sizeof (long long) =% d \ n ", sizeof (L)); // Iškviesti kaip operatorių printf (" sizeof (char) =% d \ n ", sizeof c); printf ("dydis (trumpas) =% d \ n", dydis s); printf ("dydis (int) =% d \ n", dydis i); printf ("dydis (ilgas) =% d" \ n ", l dydis); printf (" dydis (ilgas ilgas) =% d \ n ", dydis L); _getch ();)

(Manau, kad aišku, kad kintamieji gali turėti bet kokį tinkamą pavadinimą). Ši programa galėjo būti parašyta ir paprastesnė

#įtraukti #įtraukti int main () (printf ("sizeof (char) =% d \ n", sizeof (char)); printf ("sizeof (short) =% d \ n", sizeof (short)); printf ("sizeof ( int) =% d \ n ", dydis (int)); printf (" dydis (ilgas) =% d \ n ", dydis (ilgas)); printf (" dydis (ilgas ilgas) =% d \ n ", sizeof (ilgas ilgas)); // negali iškviesti sizeof kaip tipo pavadinimo operatoriaus // sizeof int - kompiliavimo klaida _getch ();)

B dalyje tas pats tipas gali turėti kelis pavadinimus.
trumpas === trumpas tarpt
ilgas === ilgas tarpt
ilgas ilgas === ilgas ilgas tarpt
nepasirašytas int === nepasirašytas

Slankaus kablelio tipai

  • plūdė- 4 baitai,
  • ilga plūdė- 8 baitai
  • dvigubai- 8 baitai
  • ilgas dvigubas- 8 baitai.
Čia taip pat yra VC2012, standartinio plūdės tipų dydžio, reikšmės<= long float <= double <= long double все числа с плавающей точкой - со знаком.

Kintamasis perpildymas

C nestebi kintamųjų perpildymo. Tai reiškia, kad nuolat didindami, tarkime, int tipo kintamojo vertę, galų gale mes „iš naujo nustatysime reikšmę“

#įtraukti #įtraukti void main () (nepasirašytas a = 4294967295; int b = 2147483647; // Unsigned type overflow printf ("% u \ n", a); a + = 1; printf ("% u", a); // Perpildymas pasirašytas tipas printf ("% d \ n", b); b + = 1; printf ("% d", b); gauti ();)

Paprastai kintamojo perpildymo elgsena apibrėžiama tik tipui nepasirašytas: sveikasis skaičius be ženklų iš naujo nustatys vertę. Kitų tipų atveju visko gali nutikti, o jei reikia saugotis perpildymo, darykite tai rankiniu būdu, tikrindami argumentus arba naudokite kitus metodus, priklausomai nuo kompiliatoriaus ir procesoriaus architektūros.

Postfix tipo žymėjimas

Kai dirbate su skaičiais, galite naudoti raides skaičiaus pabaigoje, kad aiškiai nurodytumėte jo tipą, pvz.

  • 11 - skaičius tipo int
  • 10u - nepasirašytas
  • 22l arba 22L - ilgio
  • 3890ll arba 3890LL - ilgas ilgas (taip pat lL arba Ll)
  • 80.0f arba 80.f arba 80.0F – plūduriuojantis (įraše turi būti kablelis po kablelio)
  • 3.0 – dvigubo tipo skaičius
Eksponentinis žymėjimas pagal numatytuosius nustatymus taip pat reiškia dvigubą. #įtraukti #įtraukti int main () (printf ("sizeof (int) =% d \ n", sizeof (10)); printf ("sizeof (unigned) =% d \ n", sizeof (10u)); printf ("sizeof ( long) =% d \ n ", dydis (10 l)); printf (" dydis (ilgas ilgas) =% d \ n ", dydis (10 ll)); printf (" dydis (plūduriuoti) =% d \ n ", sizeof (10.f)); printf ("sizeof (double) =% d \ n", sizeof (10.)); printf ("sizeof (double) =% d \ n", sizeof (10e2)); gauti (;)

Tačiau šis kodas negeneruos klaidų, nes yra numanomas tipo konvertavimas

Int a = 10u; dvigubas g = 3.f;

Šešioliktainis ir aštuntainis formatas

Dirbdami su skaičiais galite naudoti šešioliktainį ir aštuntainį vaizdavimo formatus. Šešioliktainiai skaičiai prasideda nuo 0x, aštuntainiai – nuo ​​nulio. Atitinkamai, jei skaičius prasideda nuliu, jame neturėtų būti skaitmenų, didesnių nei 7:

#įtraukti #įtraukti void main () (int x = 0xFF; int y = 077; printf ("hex x =% x \ n", x); printf ("dec x =% d \ n", x); printf ("oct x" =% o \ n ", x); printf (" oct y =% o \ n ", y); printf (" dec y =% d \ n ", y); printf (" hex y =% x ", y); gauti ();)

Eksponentinis skaičių žymėjimas

Eksponentinė skaičiaus vaizdavimo forma yra skaičiaus vaizdavimas forma M e ± p, kur M- mantizos numeris, p- dešimties galia. Šiuo atveju mantizoje prieš kablelį turi būti vienas ne nulis ženklas.
Pavyzdžiui, 1,25 === 1,25e0, 123,5 === 1,235e2, 0,0002341 === 2,341e-4 ir kt.
3,2435e7 rodiniai atitinka 3,2435e + 7
Taip pat yra dar viena sąvoka („inžinerija“), pagal kurią laipsnis turi būti trijų kartotinis. Pavyzdžiui, 1,25 === 1,25e0, 123,5 === 123,5e0, 0,0002341 === 234,1e-6, 0,25873256 === 258,73256e-3 ir kt.

Kintamųjų deklaravimas

C kalboje kintamieji visada deklaruojami bloko pradžioje (blokas yra kodo dalis, atskirta riestiniais skliaustais)

<возвращаемый тип> <имя функции> (<тип> <аргумент>[, <тип> <аргумент>]) (kintamieji deklaruoja visa kita)

Deklaruojant kintamąjį rašomas jo tipas ir pavadinimas.

Int a; dvigubas parametras;

Galite deklaruoti kelis to paties tipo kintamuosius, atskirdami pavadinimus kableliais

Ilgas ilgas arg1, arg2, arg3;

pavyzdžiui

#įtraukti #įtraukti int main () (int a = 10; int b; while (a> 0) (int z = a * a; b + = z;))

Čia deklaruojami kintamieji a ir b vidinė funkcija pagrindinis, ir kintamasis z kilpos korpuso viduje. Šis kodas išmes kompiliavimo klaidą

Int main () (int i; i = 10; int j;)

Taip yra todėl, kad kintamasis deklaruojamas po priskyrimo operatoriumi. Deklaruodami kintamuosius galite iš karto juos inicijuoti.
int i = 0;
Šiuo atveju inicijavimas deklaruojant kintamąjį nelaikomas atskiru teiginiu, todėl veiks toks kodas

Int main () (int i = 10; int j;)

Pradinė kintamojo reikšmė

Labai svarbu atsiminti, kad C kintamieji pagal numatytuosius nustatymus nėra inicijuojami iki nulio, kaip daugelyje kitų programavimo kalbų. Deklaravęs kintamąjį, jis išsaugo „šiukšles“ – atsitiktinę reikšmę, kuri liko atminties srityje, kuri buvo skirta kintamajam. Tai visų pirma dėl programos optimizavimo: jei nereikia inicijuoti, tada nereikia eikvoti resursų nulių rašymui (pastaba: globalūs kintamieji inicijuojami nuliais, kodėl taip, skaitykite šiame straipsnyje).

#įtraukti #įtraukti int main () (int i; printf ("% d", i); getch ();)

Jei paleisite šią programą VC, vykdymo metu pasirodys įspėjimas
Vykdymo laiko patikros klaida Nr. 3 – kintamasis „i“ naudojamas be jo inicijavimo.
Jei paspausite "Tęsti", programa parodys "šiukšles". Daugelyje kitų kompiliatorių nebus įspėjimo, kai programa bus vykdoma.

Kintamoji apimtis

Kintamieji gali būti vietiniai (deklaruojami funkcijos viduje) ir globalūs. Visuotinį kintamąjį mato visos šiame faile nurodytos funkcijos. Vietinis kintamasis apsiriboja jo apimtimi. Kai sakau, kad kintamasis „kažkur matomas“, tai reiškia, kad jis yra apibrėžtas toje vietoje ir gali būti naudojamas. Pavyzdžiui, apsvarstykite programą, kuri turi visuotinį kintamąjį

#įtraukti #įtraukti int global = 100; void foo () (printf ("foo:% d \ n", global);) void bar (int global) (printf ("bar:% d \ n", global);) int main () (foo () ; baras (333); gauti ();)

Bus išvesta
kaina: 100
baras: 333
Čia yra pasaulinis kintamasis globalus matomas visoms funkcijoms. Tačiau funkcijos argumentas perrašo visuotinį kintamąjį, todėl perduodant argumentą 333 išvedama vietinė reikšmė 333.
Štai dar vienas pavyzdys

#įtraukti #įtraukti int global = 100; int main () (int global = 555; printf ("% d \ n", global); getch ();)

Programa išspausdins 555. Kaip ir ankstesniu atveju, vietinis kintamasis yra „svarbesnis“. Pavyzdžiui, tam tikroje srityje deklaruotas kintamasis nėra matomas už jos ribų

#įtraukti #įtraukti int global = 100; int main () (int x = 10; (int y = 30; printf ("% d", x);) printf ("% d", y);)

Šis pavyzdys nebus sudarytas, nes kintamasis y egzistuoja tik jo bloke.
Štai dar vienas pavyzdys, kai bloke deklaruoti kintamieji sutampa.

#įtraukti #įtraukti int global = 100; int main () (int x = 10; (int x = 20; (int x = 30; printf ("% d \ n", x);) printf ("% d \ n", x);) printf ( "% d \ n", x); gauti ();)

Programa išves
30
20
10
Reikėtų vengti visuotinių kintamųjų. Jūs dažnai galite tai išgirsti. Pabandykime išsiaiškinti, kodėl. Jūsų paprastuose projektuose globaliai atrodo puikiai. Tačiau įsivaizduokite, kad turite tokią programą

  • 1) Sukurta kelių žmonių ir susideda iš šimtų tūkstančių kodo eilučių
  • 2) Veikia keliose gijose

Pirma, visuotinį kintamąjį, jei jis matomas visiems, gali pakeisti bet kuri programos dalis. Pakeitėte visuotinį kintamąjį, norite jį įrašyti, o kita programos dalis jame jau perrašė kitą reikšmę (iš tikrųjų tai yra visa klasė problemų, kylančių daugiagieje aplinkoje). Antra, esant dideliems projektams, neįmanoma sekti, kas ir kada sukūrė pasaulinius kintamuosius. Aukščiau pateiktuose pavyzdžiuose galite pamatyti, kaip kintamieji gali sutapti vienas su kitu, ir tas pats nutiks dideliame projekte.

Žinoma, pasitaiko situacijų, kai globalūs kintamieji supaprastina programą, tačiau tokių situacijų pasitaiko nedažnai ir ne atliekant namų darbus, todėl NEKURKITE GLOBALIŲ KINTAMŲJŲ!
Kintamieji gali būti ne tik sveikieji skaičiai ir slankusis kablelis. Yra daug kitų tipų, kuriuos išnagrinėsime vėliau.