C ++ -tyypit

C ++ -entiteetti on arvo, objekti, viite, funktio, luetteloija, tyyppi, luokan jäsen, bittikenttä, jäsennelty sidonta, nimiavaruus, malli, mallipohjan erikoistuminen tai parametripaketti. Yksikkö voi olla yhtä tai useampaa. C ++ -tyyppejä on kaksi luokkaa: perus- ja yhdistetyypit. Skalaari on aritmeettinen tai osoitinobjektityyppi. Perustyypit ovat skalaareja, kun taas muut entiteettityypit ovat yhdistetyyppejä.

Tietokoneen muisti on sarja soluja. Jokaisella solulla on yhden tavun koko, se on normaalisti Länsi-Euroopan merkin viemä tila. Kohteen koko ilmoitetaan tavuina. Tässä artikkelissa on yhteenveto C ++ -tyypeistä. Sinulla on jo oltava perustiedot C ++: sta, jotta ymmärrät tämän artikkelin.

Artikkelin sisältö

- Perustyypit
- Yhdistetyyppien rakentamisen tapoja
- Taulukot
- Luettelointi
- Luokka
- liitto
- Viitteet
- Toiminnot
- Muut yhdistetyypit
- Johtopäätös

Perustyypit

Perustyypit ovat skalaarityyppejä.

bool

Boolen tyypillä tai boolen tyypillä on tosi tai epätosi arvo 1 tai 0. Tosi tai väärä vie yhden tavun.

char, allekirjoittamaton char ja allekirjoitettu char

Hiili on tyypillisesti yksi Länsi-Euroopan merkki. Se vie tyypillisesti yhden tavun. Siellä on myös allekirjoittamaton ja allekirjoitettu merkki, joka on kukin kahdeksan bitin kokonaisluku. Allekirjoittamattomat merkit eivät sisällä negatiivisia arvoja, kun taas allekirjoitetut merkit sisältävät negatiivisia arvoja. Millainen arvo merkillä on, riippuu kääntäjästä ja voi olla vain allekirjoittamaton merkki. Näitä kolmea merkkityyppiä kutsutaan kapeiksi merkkityypeiksi, ja kukin vie yhden tavun.

Kokonaisluku

Allekirjoittamattomia vakioluku- tyyppejä on viisi ja allekirjoitettuja vakioluku- tyyppejä. Viisi allekirjoittamatonta kokonaislukutyyppiä ovat: "allekirjoittamaton merkki", "allekirjoittamaton lyhyt int", "allekirjoittamaton int", "allekirjoittamaton pitkä int" ja "allekirjoittamaton pitkä pitkä int". Viisi vastaavaa allekirjoitettua kokonaislukutyyppiä ovat: "merkitty char", "lyhyt int", "int", "pitkä int" ja "pitkä pitkä int".

”Allekirjoittamaton merkki” on samaa tyyppiä kuin kapeat merkityypit (katso yllä). ”Signeerattu merkki” on kapeiden merkkityyppien toinen tyyppi (katso yllä).

G ++ - kääntäjän kanssa "allekirjoittamaton merkki" tai "allekirjoitettu merkki" vie yhden tavun; "Allekirjoittamaton lyhyt int" tai "lyhyt int" vie kaksi tavua; "Allekirjoittamaton int" tai "int" vie neljä tavua; "Allekirjoittamaton pitkä int" tai "pitkä int" vie 8 tavua; "Allekirjoittamaton pitkä pitkä int" tai "pitkä pitkä int" vie vielä 8 tavua (nyt).

char16_t, char32_t, wchar_t

Kun käsitellään Länsi-Euroopan merkkejä, char-tyyppi riittää monissa tilanteissa. Kiinalaisia ja muita itäisiä kieliä käsiteltäessä tarvitaan kuitenkin char16_t, char32_t tai wchar_t. G ++ - kääntäjän avulla char16_t vie kaksi tavua; char32_t vie neljä tavua ja wchar_t myös neljä tavua.

Bool-, char-, char16_t-, char32_t-, wchar_t-, allekirjoitetut ja allekirjoittamattomat kokonaislukutyypit muodostavat toisen joukon, jota kutsutaan integraaleiksi (kokonaisluku).

Artikkelin tässä kohdassa on mainittu kaksi kollektiivista tyyppiä: kapeat merkkityypit ja integraalityypit.

Liukulukutyypit

Oletetaan, että luvut 457 000 ja 457 230 ovat sama lukema mitattuna kahdella eri mittalaitteella. 457 230 on tarkempi kuin 457 000, koska arvo on yksityiskohtaisempi (sisältää pienempiä paikkoja: + 200 plus 30). Liukuluku on luku, jossa on murto-osa (desimaali). Vaikka tietokoneen numerot ovat bittisarja, jotkut liukuluvut ovat tarkempia kuin toiset.

Jotkut mittauslaitteet tekevät mittauksia vähimmäisvaiheissa, esimerkiksi 10 yksikköä. Tällaisella instrumentilla olisi seuraavat lukemat: 10, 20, 30, 40,… 100, 110, 130, 140,… 200, 210, 220, 230, 240 ja niin edelleen. Vaikka tietokoneen numerot ovat bittisarja, liukuluvut vaihtelevat joissakin vähimmäisvaiheissa (paljon pienempiä kuin 10 yksikköä).

C ++: lla on kolme liukulukutyyppiä, jotka ovat: kelluva, kaksinkertainen ja pitkä kaksinkertainen. Minkä tahansa kääntäjän kaksoiskappaleella on oltava tarkkuus, joka on korkeampi kuin kelluvan tai ainakin kelluvan tarkkuus; Pitkällä kaksoiskappaleella on oltava tarkkuus, joka on korkeampi kuin kaksinkertaisella tai ainakin kaksinkertaisella.

On olemassa kolmas yhteisnimi: aritmeettinen tyyppi. Tämä on nimi integraaleille ja liukulukuille. Huomaa, että tämä on myös kaikkien skalaarityyppien nimi, kuten tähän mennessä on selitetty.

G ++ - kääntäjällä kellun tavujen määrä on neljä; tuplan tavujen lukumäärä on kahdeksan; pitkän tuplan tavujen lukumäärä on kuusitoista.

void Tyyppi

G ++ -kääntäjällä tyhjätyypin koko on yksi tavu. Tavulla ei virallisesti ole bittiä, eli sen sijainnissa on tyhjää sisältöä.

Yhdistetyyppien rakentamisen tapoja

Yhdistetyypit eivät ole perustyyppejä. Tämä tarkoittaa, että yhdistetyypit eivät ole skalaarisia tyyppejä. Tässä osassa selitetään yhdistetyyppien perusteet.

Taulukot

Seuraava koodisegmentti näyttää joukon intoja ja joukkoa merkkejä:

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

Luettelointi

Luettelo on tyyppi, jolla on nimetty vakioita. Harkitse seuraavaa koodisegmenttiä:

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

Lähtö on: 4. Koodisegmentin ensimmäinen rivi on luettelo ja a, b tai c on luetteloija.

Luokka

Luokka on yleistetty yksikkö, josta voidaan luoda monia saman yleistetyn yksikön objekteja (ilmentää). Seuraava ohjelma näyttää luokan ja kaksi objektia, heti sen perusteella. Tällainen kohde eroaa skalaariobjektista.

#sisältää
käyttämällä nimitilaa vakio;
luokka TheCla

julkinen:
int numero = 5;
int fn ()

paluu numero;

;
int main ()

The Cla obj1;
The Cla obj2;
cout << obj1.num << " << obj2.num <<'\n';
paluu 0;

Lähtö on: 5 5. Luokan nimi on TheCla, ja kahden objektin nimet ovat obj1 ja obj2. Huomaa puolipiste heti luokan kuvauksen (määritelmän) jälkeen. Huomaa, kuinka nämä kaksi objektia ilmentyivät main () -funktiossa.

Huomaa: num on datajäsen ja fn on jäsenfunktio.

liitto

rakenne

Rakenne on kuin matriisi, mutta sen sijaan, että sillä olisi indeksi / arvo-pareja, sillä on nimi / arvo-pareja. Nimet voidaan kirjoittaa missä tahansa järjestyksessä. Seuraava ohjelma näyttää rakenteen ja sen käytön:

#sisältää
käyttämällä nimitilaa vakio;
strukturoi TheCla

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

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

Tuotos on:

5, 2.3, a

Rakenteen nimi on TheCla. obj1 ja obj2 ovat kaksi eri objektia strukturissa.

liitto

Seuraava ohjelma näyttää liiton ja sen käytön:

#sisältää
käyttämällä nimitilaa vakio;
liitto TheCla

int numero;
kelluva flt = 2.3;
char ch;
obj1, obj2;
int main ()

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

Lähtö on: 2.3. Liitto on samanlainen kuin rakenne. Tärkein ero strukturin ja liiton välillä on se, että rakenteessa vain yhdellä jäsenellä voi olla arvo (alustettu) kerrallaan. Edellä olevassa ohjelmassa jäsenen flt arvo on 2.3. Jokaisella muulla jäsenellä, num tai ch, voi olla seuraava arvo vain, jos flt: n arvo hylätään.

Viitteet

Viite on tunnisteen synonyymi. Seuraava koodisegmentti näyttää kuinka saada viite tunnisteeseen:

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

Lähtö on: 5 5 5. ref1 ja ref2 ovat synonyymeja tunnukselle.

lvalue Reference ja rvalue Reference

Yllä olevat viitteet ovat arvoarvoja. Seuraava koodi näyttää arvon viitearvon:

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

Lähtö on: 5. Tämä viite luodaan tunnistamatta mitään sijaintia muistissa. Tämän saavuttamiseksi tarvitaan kaksinkertainen &, ts.e., &&.

Osoitin

Osoitin ei oikeastaan ole C ++ -entiteetti. Se tarjoaa kuitenkin paremman järjestelmän viittausten käsittelemiseksi. Seuraava koodi näyttää, miten osoitin voidaan luoda:

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

Lähtö on: 5. Huomaa ptdId- ja ptdId-nimien ero. ptdId on terävä esine ja ptrId on osoitinobjekti. & ptdId palauttaa ptrId: lle määritetyn terävän objektin osoitteen. Palauta teräväkohteen arvo käyttämällä * ptrId.

Toiminnot

Perustoiminto ja sen kutsu

Seuraava koodi näyttää perustoiminnon määritelmän ja sen kutsun:

#sisältää
käyttämällä nimitilaa vakio;
int fn (int numero)

cout<<"seen"<<'\n';
paluu numero;

int main ()

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

Tulos on

toiminnon määrittely

Toimintakutsu on fn (5). Funktion nimi on fn.

Toiminnon viite ja osoitin

& fn palauttaa osoitteen sen funktion muistiin, jonka nimi on fn. Seuraava lause julistaa osoittimen funktiolle:

int (* func) ();

Tässä funktio on funktion osoittimen nimi. Ensimmäiset sulut parit erottavat tämän funktion osoittimen skalaarisesta objektiosoittimesta. func voidaan saada pitämään fn: llä tunnistetun funktion osoite seuraavasti:

func = &fn;

Seuraava ohjelma asettaa toimintoviitteen ja osoittimen toimintaan:

#sisältää
käyttämällä nimitilaa vakio;
int fn (int numero)

/ * joitain lausuntoja * /
paluu numero;

int main ()

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

Lähtö on: 5. Huomaa, että sekä fn: llä että func: lla on int-parametri ilmoituksessa.

Muut yhdistetyypit

Edellä mainitut perusyhdistetyypit ovat yhdisteitä sinänsä. Niitä käytetään myös kehiteltyjen yhdistetyyppien rakentamiseen.

typedef

Typedef varattua sanaa käytetään korvaamaan tyyppisarja yhdellä nimellä (sekvenssille). Seuraava koodisegmentti kuvaa tätä:

typedef allekirjoittamaton pitkä int IduIL;

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

Tuotos on 555555555555555555. Koodissa IduIL: stä on tullut tyyppi, joka tarkoittaa "unsigned long int".

Strukturoitu sidonta

Strukturoitu sidonta on ominaisuus, joka mahdollistaa nimien antamisen alikohteille. Seuraava koodi kuvaa tätä taulukkoa:

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

Lähtö on 1 2 3. Joten arvoille: 1, 2, 3 on annettu nimet, x, y, z. Huomaa varatun sanan käyttö ja sijainti. Huomaa myös hakasulkeiden käyttö.

Bit-kenttä

Muisti on solusarja. Jokainen solu vie tavun. Jokainen tavu koostuu myös kahdeksasta bitistä. Bittien ryhmä, ei välttämättä kahdeksan bittiä, voidaan asettaa ja muuttaa. Tällaista ryhmää kutsutaan bittikentäksi. Nämä ryhmät makaavat vierekkäin. Jos ryhmät eivät muodosta tyyppiä, sanotaan 16 bittiä lyhyelle intille, täytepalat lisätään. Seuraava koodi kuvaa tätä strukturilla:

struct Päivämäärä

allekirjoittamaton lyhyt wkDay: 3; // 3 bittiä
allekirjoittamaton lyhyt maPäivä: 6; // 6 bittiä
allekirjoittamaton lyhyt ma: 5; // 5 bittiä
allekirjoittamaton lyhyt vuosi: 8; // 8 bittiä kaksinumeroisella vuodella
dte;
dte.wkDay = 1; dte.monPäivä = 2; dte.mon = 2; dte.vuosi = 21;
cout << dte.mon <<'/'<< dte.monDay <<'/'<< dte.yr <<'\n';

Lähtö on: 2/2/21. Bittien kokonaismäärä wkDay, MonDay ja mon on 3 + 6 + 5 = 14. Joten lisätään kaksi täytebittiä muodostamaan 16 bittiä 2 tavun lyhyelle kokonaisluvulle (16 bittiä). Seuraavat 8 bittiä alkavat seuraavan lyhyen intin, joka sitten täytetään 8 täytepalalla.

Huomaa: Vältä bittikenttien käyttöä; käytä sitä vain tutkimukseen.

Nimitila

Nimitila on nimiryhmä, joka ei saa olla ristiriidassa muiden nimiryhmien samojen nimien kanssa. Seuraava ohjelma havainnollistaa samojen nimien käyttöä kahdesta eri nimiavaruudesta, jota käytetään pääfunktion () nimitilassa:

#sisältää
käyttämällä nimitilaa vakio;
nimitila NS1

int myInt = 8;
kelluva flt;

nimitila NS2

int myInt = 9;
kelluva 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';
paluu 0;

Tuotos on:

2.5

4.8

Koodissa on kaksi ristiriitaista samaa int-nimeä ja kaksi ristiriitaista samaa float-nimeä.

Mallien ja mallien erikoistuminen

Mallimalli sallii paikkamerkin käytön erilaisille skalaarityypeille. Erikoistuminen on tietyn skalaarityypin valitseminen. Seuraava koodi kuvaa tätä funktiota varten:

#sisältää
käyttämällä nimitilaa vakio;
malli void func (T cha, U no)

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

int main ()

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

Tuotos on:

"Tarvitsen leipää 3 dollaria.”

Malliparametripaketti

Kääntäjien on vielä toteutettava tämä ominaisuus täysimääräisesti - katso myöhemmin.

Johtopäätös

C ++ -tyyppejä on kahdessa luokassa: perustyypit ja yhdistetyypit. Perustyypit ovat skalaarityyppejä. Perusyhdistelmätyypit ovat taulukot, luettelot, luokat, liitot, viitteet, osoittimet ja funktiot. Näitä perusyhdistetyyppejä käytetään rakentamaan laadittuja yhdistetyyppejä, jotka ovat typedef, strukturoidut sidokset, bittikentät, nimiavaruus ja malliominaisuudet.

Chrys