C ++ tüübid

C ++ olem on väärtus, objekt, viide, funktsioon, loendaja, tüüp, klassi liige, bitiväli, struktureeritud sidumine, nimeruum, mall, malli spetsialiseerumine või parameetrite pakett. Üksus võib olla ühte või mitut tüüpi. C ++ tüüpe on kahte kategooriat: põhi- ja liitliigid. Skalaar on aritmeetiline või osutiobjekti tüüp. Põhitüübid on skalaarid, ülejäänud olemi tüübid on ühenditüübid.

Arvuti mälu on rakkude jada. Igal lahtril on ühe baidi suurus, tavaliselt on see ruum, mille hõivab Lääne-Euroopa tegelane. Objekti suurus on antud baitides. Selles artiklis antakse kokkuvõte C ++ tüüpidest. Selle artikli mõistmiseks peaksite juba omama põhiteadmisi C ++ kohta.

Artikli sisu

- Põhitüübid
- Ühenditüüpide ehitamise viisid
- Massiivid
- Loendamine
- Klass
- Liit
- Viited
- Funktsioonid
- Muud ühenditüübid
- Järeldus

Põhitüübid

Põhitüübid on skalaartüübid.

bool

Boole'i või tõeväärtuse tüübi väärtus on 1 või 0 tõene või väär. Õige või vale võtab ühe baidi.

char, allkirjastamata char ja allkirjastatud char

Süsi on tavaliselt ühe Lääne-Euroopa tegelase jaoks. Tavaliselt hõivab see ühe baidi. Samuti on allkirjastamata ja allkirjastatud tähemärk, millest igaüks on kaheksa-bitine täisarv. Allkirjastamata tähemärgid ei hõlma negatiivseid väärtusi, allkirjastatud tähed aga negatiivseid. See, millist väärtust char omab, sõltub kompilaatorist ja see võib olla lihtsalt allkirjastamata char. Neid kolme tüüpi sümboleid nimetatakse kitsasteks tähemärkide tüüpideks ja mõlemad hõivavad ühe baidi.

Täisarv

Seal on viis allkirjastamata standardset täisarvu tüüpi ja viis allkirjastatud standardset täisarvu tüüpi. Viis allkirjata täisarvu tüüpi on: "unsigned char", "unsigned short int", "unsigned int", "unsigned long int" ja "unsigned long long int". Viis vastavat allkirjastatud täisarvu tüüpi on: „signeeritud char“, „lühike int“, „int“, „pikk int“ ja „pikk pikk int“.

„Unsigned char” on sama tüüpi kui kitsad tähemärgitüübid (vt eespool). „Signeeritud täht“ on kitsaste tähemärkide tüüpide teine tüüp (vt eespool).

G ++ kompilaatori abil hõivab „signeerimata char” või „signeeritud char” ühe baidi; „Allkirjastamata lühike int” või „lühike int” võtab kaks baiti; „Allkirjastamata int” või „int” võtab neli baiti; „Allkirjastamata pikk int” või „pikk int” võtab 8 baiti; "Allkirjastamata pikk pikk int" või "pikk pikk int" võtab endiselt 8 baiti (praeguse seisuga).

char16_t, char32_t, wchar_t

Lääne-Euroopa tegelastega suheldes on paljudes olukordades piisav char-tüüp. Hiina ja teiste idakeeltega suheldes on aga vajalik char16_t või char32_t või wchar_t. Koostajaga g ++ hõivab char16_t kaks baiti; char32_t hõivab neli baiti ja wchar_t ka neli baiti.

Bool, char, char16_t, char32_t, wchar_t, signeeritud ja allkirjastamata täisarvutüübid moodustavad teise hulga, mida nimetatakse integraal (täisarv) tüüpideks.

Artikli selles punktis on mainitud kahte kollektiivset tüüpi: kitsad tähemärgitüübid ja integraalsed tüübid.

Ujuvate punktide tüübid

Oletame, et numbrid 457 000 ja 457 230 on sama näit, mõõdetuna kahe erineva mõõtevahendiga. 457 230 on täpsem kui 457 000, kuna väärtus on üksikasjalikum (hõlmab väiksemaid kohti: + 200 pluss 30). Ujukomaarv on murdosa (kümnendkohaga) arv. Ehkki arvutis olevad numbrid on bittide jada, on mõned ujukomaarvud täpsemad kui teised.

Mõni mõõteriist teeb mõõtmisi minimaalsete sammudega, näiteks 10 ühikut. Sellisel instrumendil oleksid järgmised näidud: 10, 20, 30, 40,… 100, 110, 130, 140,… 200, 210, 220, 230, 240 ja nii edasi. Ehkki arvutis olevad arvud on bittide jada, ulatuvad ujukomaarvud teatud miinimumtappidena (palju väiksemad kui 10 ühikut).

C ++ -l on kolm ujukoma tüüpi, mis on: ujuk-, topelt- ja pikk-topelt. Iga kompilaatori puhul peab topelt täpsus olema kõrgem kui ujukil või vähemalt ujukil; pika duubli täpsus peab olema kõrgem kui kahekordsel või vähemalt kahekordsel.

On veel kolmas koondnimi: aritmeetiline tüüp. See on integraal- ja ujukoma tüüpide nimi. Pange tähele, et see on ka kõigi skalaartüüpide nimi, nagu seni selgitatud.

Kompilaatori g ++ puhul on ujuki baitide arv neli; duubli baitide arv on kaheksa; pika duubli baitide arv on kuusteist.

void Type

Kompilaatori g ++ korral on void-tüübi suurus üks bait. Baidil pole ametlikult bitti, see tähendab, et selle asukohas on tühi sisu.

Ühenditüüpide ehitamise viisid

Ühenditüübid ei ole fundamentaalsed tüübid. See tähendab, et ühenditüübid on mitteskalaarsed tüübid. Selles jaotises selgitatakse ühenditüüpide põhitõdesid.

Massiivid

Järgmine koodilõik näitab massiivide inte ja tähemassiivi:

int arrInt [] = 1, 2, 3, 4, 5;
char arrCha [] = 'a', 'b', 'c', 'd', 'e';
cout << arrInt[2] <<" <Väljund on: 3 c.

Loendamine

Loendamine on tüüp, millel on konstandid. Mõelge järgmisele koodisegmendile:

loend a = 3, b, c;
cout << b <<'\n';

Väljund on: 4. Koodisegmendi esimene rida on loend ja a, b või c on loendaja.

Klass

Klass on üldistatud üksus, millest saab luua (üldistada) palju sama üldistatud üksuse objekte. Järgmine programm näitab klassi ja kahte objekti, mis on sellest instantiseeritud. Selline objekt erineb skalaarobjektist.

# kaasata
nimeruumi kasutamine std;
klass TheCla

avalik:
int arv = 5;
int fn ()

return number;

;
int main ()

TheCla obj1;
TheCla obj2;
cout << obj1.num << " << obj2.num <<'\n';
tagastama 0;

Väljund on: 5 5. Klassi nimi on TheCla ja kahe objekti nimed on obj1 ja obj2. Pange tähele semikoolon vahetult pärast klassi kirjeldust (definitsiooni). Pange tähele, kuidas need kaks objekti põhifunktsioonis () instantsiti.

Märkus: num on andmeliige ja fn on liikme funktsioon.

Liit

struktuur

Struktuur on nagu massiiv, kuid indeksi / väärtuse paaride asemel on sellel nime / väärtuse paarid. Nimesid võib kirjutada mis tahes järjekorras. Järgmine programm näitab struktuuri ja selle kasutamist:

# kaasata
nimeruumi kasutamine std;
struktureeritud TheCla

int arv = 5;
ujuk flt = 2.3;
char ch = 'a';
obj1, obj2;
int main ()

cout << obj2.num <<", "<< obj2.flt <<", "<< obj2.ch <<'\n';
tagastama 0;

Väljund on:

5, 2.3, a

Struktuuri nimi on TheCla. obj1 ja obj2 on struktuuri kaks erinevat objekti.

Liit

Järgmine programm näitab liitu ja selle kasutamist:

# kaasata
nimeruumi kasutamine std;
liit TheCla

int number;
ujuk flt = 2.3;
char ch;
obj1, obj2;
int main ()

cout << obj2.flt <<'\n';
tagastama 0;

Väljund on: 2.3. Liit sarnaneb struktuuriga. Peamine erinevus struktuuri ja liidu vahel on see, et struktuuri jaoks võib väärtus (initsialiseeritud) olla ainult ühel liikmel korraga. Ülaltoodud programmis on liikme, flt väärtus 2.3. Kõigil teistel liikmetel, num või ch, saab järgmine väärtus olla ainult siis, kui flt väärtusest loobutakse.

Viited

Viide on identifikaatori sünonüüm. Järgmine koodisegment näitab, kuidas saada viide identifikaatorile:

int id = 5;
int & ref1 = id;
int & ref2 = id;
cout << id << " << ref1 << " << ref2 <<'\n';

Väljund on: 5 5 5. ref1 ja ref2 on id-i sünonüümid.

lvalue Reference ja rvalue Reference

Ülaltoodud viited on väärtusväärtused. Järgmine kood näitab väärtuse viidet:

int && ref = 5;
cout << ref <<'\n';

Väljund on: 5. See viide luuakse mälu asukohta tuvastamata. Selle saavutamiseks on vaja kahekordset &, st.e., &&.

Pointer

Kursor pole tegelikult C ++ üksus. See annab siiski parema skeemi viidetega tegelemiseks. Järgmine kood näitab, kuidas osutit saab luua:

int ptdId = 5;
int ptdId = 5;
int * ptrId;
ptrId = &ptdId;
cout << *ptrId <<'\n';

Väljund on: 5. Pange tähele ptdId ja ptdId nimevahet. ptdId on terav objekt ja ptrId on kursori objekt. & ptdId tagastab ptrId-le määratud terava objekti aadressi. Terava objekti väärtuse tagastamiseks kasutage klahvi * ptrId.

Funktsioonid

Põhifunktsioon ja selle väljakutse

Järgmine kood näitab põhifunktsiooni määratlust ja selle väljakutset:

# kaasata
nimeruumi kasutamine std;
int fn (int number)

cout<<"seen"<<'\n';
return number;

int main ()

int ret = fn (5);
cout << ret <<'\n';
tagastama 0;

Väljund on

funktsiooni määratlus

Funktsioonikõne on fn (5). Funktsiooni nimi on fn.

Funktsiooni viide ja osutaja

& fn tagastab aadressi funktsiooni mällu, mille nimi on fn. Järgmine lause deklareerib funktsiooni kursori:

int (* func) ();

Siin on func funktsiooni kursori nimi. Esimene sulgude paar eristab seda funktsiooni osutit skalaarse objekti kursorist. Funktsiooni func saab panna fn-ga identifitseeritud funktsiooni aadressi hoidmiseks järgmiselt:

func = &fn;

Järgmine programm paneb funktsiooni viite ja kursori tööle:

# kaasata
nimeruumi kasutamine std;
int fn (int number)

/ * mõned avaldused * /
return number;

int main ()

int (* func) (int);
func = &fn;
int ret = func (5);
cout << ret <<'\n';
tagastama 0;

Väljund on: 5. Pange tähele, et nii fn kui ka func on deklaratsioonis int parameeter.

Muud ühenditüübid

Ülaltoodud põhiühenditüübid on iseenesest ühendid. Neid kasutatakse ka väljatöötatud ühenditüüpide konstrueerimiseks.

typedef

Typedef reserveeritud sõna kasutatakse tüübijada asendamiseks ühe nimega (jada jaoks). Järgmine koodilõik illustreerib seda:

typedef allkirjastamata pikk int IduIL;

IduIL myInt = 55555555555555555555;
cout << myInt <<'\n';

Väljundiks on 555555555555555555. Koodis on IduIL muutunud tüübiks, mis tähistab allkirjastamata pikka int.

Struktureeritud sidumine

Struktureeritud köitmine on funktsioon, mis võimaldab alamobjektidele nimesid anda. Massiivi illustreerib järgmine kood:

int arr [3] = 1, 2, 3;
auto [x, y, z] (arr);
cout << x <<"<< y <<"<< z <<'\n';

Väljundiks on 1 2 3. Niisiis, väärtustele: 1, 2, 3 on antud nimed x, y, z. Pange tähele reserveeritud sõna automaatne kasutamine ja asukoht. Pange tähele ka nurksulgude kasutamist.

Bit-väli

Mälu on rakkude järjestus. Iga lahter võtab baidi. Samuti koosneb iga bait kaheksast bitist. Bittide rühma, mitte tingimata kaheksa bitti, saab määrata ja muuta. Sellist rühma nimetatakse bitiväljaks. Need rühmad lebaksid üksteise kõrval. Kui rühmad ei moodusta tüüpi, öelge lühikese int-i jaoks 16 bitti, lisatakse poldid. Järgmine kood illustreerib seda struktuuriga:

struct Kuupäev

allkirjastamata lühike wkDay: 3; // 3 bitti
allkirjastamata lühike esmaspäev: 6; // 6 bitti
allkirjastamata lühike esmaspäev: 5; 5 bitti
allkirjastamata lühike aasta: 8; // 8 bitti kahekohaliseks aastaks
dte;
dte.wkDay = 1; dte.esmaspäev = 2; dte.mon = 2; dte.a = 21;
cout << dte.mon <<'/'<< dte.monDay <<'/'<< dte.yr <<'\n';

Väljund on: 2/2/21. WkDay, MonDay ja mon bittide koguarv on 3 + 6 + 5 = 14. Niisiis lisatakse kaks polti, et moodustada 2-baidise (16-bitise) lühikese täisarvu jaoks 16 bitti. Järgmised 8 bitti alustavad järgmist lühikest int, mis seejärel täidetakse 8 poldiga.

Märkus. Vältige bitiväljade kasutamist; kasutage seda ainult uurimistööks.

Nimeruum

Nimeruum on nimede kogum, mis ei tohiks olla vastuolus teiste nimede komplektide samade nimedega. Järgmine programm illustreerib samade nimede kasutamist kahest erinevast nimeruumist, rakendatuna funktsiooni main () nimeruumis:

# kaasata
nimeruumi kasutamine std;
nimeruum NS1

int myInt = 8;
ujuk flt;

nimeruum NS2

int myInt = 9;
ujuk flt;

int main ()

cout << NS1::myInt << '\n';
cout << NS2::myInt << '\n';
NS1 :: flt = 2.5;
NS2 :: flt = 4.8;
cout << NS1::flt << '\n';
cout << NS2::flt << '\n';
tagastama 0;

Väljund on:

2.5

4.8

Koodis on kaks vastuolulist sama int-nime ja kaks vastuolulist sama ujukinime.

Mallide ja mallide spetsialiseerumine

Malliskeem lubab erinevate võimalike skalaartüüpide jaoks kasutada kohahoidjat. Spetsialiseerumine on konkreetse skalaartüübi valimine. Järgmine kood illustreerib seda funktsiooni jaoks:

# kaasata
nimeruumi kasutamine std;
mall void func (T cha, U ei)

cout << "I need bread for " << cha << no << '.' << '\n';

int main ()

func ('$', 3);
tagastama 0;

Väljund on:

"Mul on vaja leiba 3 dollari eest.”

Malliparameetrite pakett

Koostajad peavad selle funktsiooni täielikult rakendama - vt hiljem.

Järeldus

C ++ tüübid eksisteerivad kahes kategoorias: põhitüübid ja ühenditüübid. Põhitüübid on skalaartüübid. Põhilised ühenditüübid on massiivid, loendused, klassid, liidud, viited, osutid ja funktsioonid. Neid põhilisi ühenditüüpe kasutatakse väljatöötatud ühenditüüpide loomiseks, milleks on typedef, struktureeritud sidemed, bitiväljad, nimeruum ja malli funktsioonid.

Chrys