C ++ typer
Minnet om en datamaskin er en serie celler. Hver celle har størrelsen på en byte, den er normalt plassen som er okkupert av en vest -europeisk karakter. Størrelsen på et objekt er gitt i byte. Denne artikkelen gir et sammendrag av C ++ -typer. Du bør allerede ha grunnleggende kunnskap om C ++, for å forstå denne artikkelen.
Artikkelinnhold
- Grunnleggende typer
- Måter å konstruere sammensatte typer
- Matriser
- Oppregning
- Klasse
- Union
- Referanser
- Funksjoner
- Andre sammensatte typer
- Konklusjon
Grunnleggende typer
Grunnleggende typer er skalartyper.
bool
En boolsk type eller bool -type har en verdi av ekte eller usant for 1 eller 0. Sann eller falsk okkuperer en byte.
røye, usignert røye, og signerte røye
En røye er typisk for en vest -europeisk karakter. Det okkuperer typisk en byte. Det er også en usignert og signert røye, som hver er et åtte-bits heltall. Usignede rolle involverer ikke negative verdier, mens signerte ranger involverer negative verdier. Den typen verdi en røye har avhenger av kompilatoren og kan bare være en usignert røye. Disse tre typene chars kalles, smale karaktertyper, og hver okkuperer en byte.
Heltall
Det er fem usignerte standard heltalltyper og fem signerte standard heltalltyper. De fem usignerte heltallstypene er: “Unsigned Char”, “Unsigned Short Int”, “Unsigned Int”, “Unsigned Long Int” og “Unsigned Long Long Int”. De fem tilsvarende signerte heltallstypene er: “Signert char”, “Short Int”, “Int”, “Long Int” og “Long Long Int”.
“Unsigned Char” er samme type som de smale karaktertypene (se over). “Signert char” er den andre typen av de smale karaktertypene (se over).
Med G ++ -kompilatoren okkuperer “Unsigned Char” eller “Signed Char” en byte; “Unsigned Short Int” eller “Short Int” okkuperer to byte; “Unsigned Int” eller “Int” okkuperer fire byte; “Unsigned Long Int” eller “Long Int” okkuperer 8 byte; “Unsigned Long Long Int” eller “Long Long Int” okkuperer fortsatt 8 byte (per nå).
char16_t, char32_t, wchar_t
Når du arbeider med vesteuropeiske karakterer, er røye -typen nok i mange situasjoner. Når du arbeider med kinesiske og andre østlige språk, er det imidlertid nødvendig. Med G ++ -kompilatoren okkuperer char16_t to byte; char32_t okkuperer fire byte og wchar_t okkuperer også fire byte.
The Bool, The Char, Char16_T, Char32_T, WCHAR_T, de signerte, og de usignerte heltallstypene, danner et annet sett, kalt Integral (Heltall) -typer.
På dette tidspunktet i artikkelen har to kollektive typer blitt nevnt: smale karaktertyper og integrerte typer.
Flytende punkttyper
Anta at tallene 457.000 og 457.230 er den samme lesningen, målt med to forskjellige måleinstrumenter. 457,230 er mer presis enn 457 000 fordi verdien er mer detaljert (involverer mindre steder: + 200 pluss 30). Et flytende punktnummer er et tall med en brøk (desimal) del. Selv om tall i datamaskinen er en sekvens av biter, er noen flytende punkttall mer presise enn de andre.
Noen måleinstrumenter tar målinger i minimumstrinn, sier 10 enheter. Et slikt instrument ville ha følgende avlesninger: 10, 20, 30, 40, ... 100, 110, 130, 140, ... 200, 210, 220, 230, 240, og så videre. Selv om tall i datamaskinen er en sekvens av biter, varierer flytende punkt i noen minimumstrinn (mye mindre enn 10 enheter).
C ++ har tre flytende punkttyper, som er: Float, Double og Long Double. For enhver kompilator må dobbelt ha den presisjonen som er høyere enn flyten eller i det minste den til Float; lang dobbel må ha presisjonen som er høyere enn for dobbelt eller i det minste den til dobbel.
Det er et tredje kollektivnavn: aritmetisk type. Dette er navnet for integrerte og flytende punkttyper. Merk at dette også er navnet på alle skalortypene, som forklart så langt.
Med G ++ -kompilatoren er antall byte for en flottør fire; Antall byte for en dobbel er åtte; antall byte for en lang dobbel er seksten.
tomromstype
Med G ++ -kompilatoren er størrelsen på tomromstypen en byte. Byte har offisielt ingen biter, noe som betyr at beliggenheten har tomt innhold.
Måter å konstruere sammensatte typer
Sammensatte typer er ikke-fundamental typer. Dette betyr at sammensatte typer er ikke-skala-typer. Denne delen forklarer det grunnleggende om sammensatte typer.
Matriser
Følgende kodesegment viser en rekke INTS og en rekke chars:
int arrint [] = 1, 2, 3, 4, 5;char archa [] = 'a', 'b', 'c', 'd', 'e';
cout << arrInt[2] <<" <
Oppregning
En oppregning er en type, med navngitte konstanter. Tenk på følgende kodesegment:
enum a = 3, b, c;cout << b <<'\n';
Utgangen er: 4. Den første linjen i kodesegmentet er en oppregning, og A, B eller C er en oppregning.
Klasse
En klasse er en generalisert enhet som mange objekter med den samme generaliserte enheten kan opprettes (instantiert). Følgende program viser en klasse og to objekter, instantiert fra det. Et slikt objekt er forskjellig fra et skalært objekt.
#inkludereved hjelp av navneområdet STD;
Klasse thecla
offentlig:
int num = 5;
int fn ()
return num;
;
int main ()
Thecla obj1;
Thecla obj2;
cout << obj1.num << " << obj2.num <<'\n';
retur 0;
Utgangen er: 5 5. Navnet på klassen er Thecla, og navnene på de to objektene er obj1 og obj2. Legg merke til semikolonet like etter beskrivelsen (definisjonen) av klassen. Legg merke til hvordan de to objektene ble instantiert i hovedfunksjonen ().
Merk: NUM er et datamedlem og FN er medlemsfunksjon.
Union
struktur
En struktur er som en matrise, men i stedet for å ha indeks/verdipar, har den navn/verdipar. Navnene kan skrives i hvilken som helst rekkefølge. Følgende program viser en struktur og bruken av den:
#inkludereved hjelp av navneområdet STD;
struct thecla
int num = 5;
FLOAT FLT = 2.3;
char ch = 'a';
obj1, obj2;
int main ()
cout << obj2.num <<", "<< obj2.flt <<
","<< obj2.ch <<'\n';
retur 0;
Utgangen er:
5, 2.3, aNavnet på strukturen er Thecla. obj1 og obj2 er to forskjellige objekter i strukturen.
Union
Følgende program viser en fagforening og bruken av den:
#inkludereved hjelp av navneområdet STD;
Union thecla
int num;
FLOAT FLT = 2.3;
char ch;
obj1, obj2;
int main ()
cout << obj2.flt <<'\n';
retur 0;
Utgangen er: 2.3. Unionen ligner en struktur. Hovedforskjellen mellom en struktur og en union er at for en struktur er det bare ett medlem som kan ha en verdi (initialisert) når som helst. I programmet ovenfor, medlemmet, har FLT en verdi på 2.3. Hvert av de andre medlemmene, NUM eller CH, kan bare ha en verdi neste hvis verdien for FLT blir forlatt.
Referanser
En referanse er et synonym for en identifikator. Følgende kodesegment viser hvordan du får en referanse til en identifikator:
int id = 5;int & ref1 = id;
int & ref2 = id;
cout << id << " << ref1 <<
"" << ref2 <<'\n';
Utgangen er: 5 5 5. Ref1 og Ref2 er synonymer til ID.
Lvalue Reference og Rvalue Reference
Ovennevnte referanser er lValue referanser. Følgende kode viser Rvalue -referanse:
int && ref = 5;cout << ref <<'\n';
Utgangen er: 5. Denne referansen opprettes uten å identifisere noe sted i minnet. For å oppnå dette, dobbelt og trengs, jeg.e., &&.
Peker
En peker er egentlig ikke en C ++ enhet. Imidlertid gir det et bedre ordning for å håndtere referanser. Følgende kode viser hvordan en peker kan opprettes:
int ptDID = 5;int ptDID = 5;
int *ptrid;
ptrid = &ptdId;
cout << *ptrId <<'\n';
Utgangen er: 5. Legg merke til forskjellen i navn mellom PTDID og PTDID. PtDID er det spisse objektet og ptrid er pekerobjektet. & ptdid returnerer adressen til det spisse objektet som er tilordnet ptrid. For å returnere verdien av det spisse objektet, bruk *ptrid.
Funksjoner
Grunnleggende funksjon og dens samtale
Følgende kode viser en grunnleggende funksjonsdefinisjon og dens samtale:
#inkludereved hjelp av navneområdet STD;
int fn (int num)
cout<<"seen"<<'\n';
return num;
int main ()
int ret = fn (5);
cout << ret <<'\n';
retur 0;
Utgangen er
sett5
Funksjonssamtalen er FN (5). Navnet på funksjonen er fn.
Referanse og peker til en funksjon
& fn returner adressen til minne om funksjonen hvis navn er fn. Følgende uttalelse erklærer en peker til en funksjon:
int (*func) ();Her er func navnet på pekeren til funksjonen. Det første par parenteser skiller denne funksjonspekeren fra en skalær objektpeker. func kan lages for å holde adressen til en funksjon identifisert av FN, som følger:
func = &fn;Følgende program setter funksjonsreferansen og pekeren ut i handling:
#inkludereved hjelp av navneområdet STD;
int fn (int num)
/ * Noen utsagn */
return num;
int main ()
int (*func) (int);
func = &fn;
int ret = func (5);
cout << ret <<'\n';
retur 0;
Utgangen er: 5. Merk at både FN og Func hver har INT -parameteren i erklæringen.
Andre sammensatte typer
Ovennevnte grunnleggende sammensatte typer er sammensatte i seg selv. De brukes også til å konstruere utdypede sammensatte typer.
typedef
Det typedef reserverte ordet brukes til å erstatte en sekvens av typer med ett navn (for sekvensen). Følgende kodesegment illustrerer dette:
typedef usignert lang int iduil;Iduil Myint = 55555555555555555555;
cout << myInt <<'\n';
Utgangen er 55555555555555555555. I koden har Iduil blitt en type som står for "usignert lang int".
Strukturert binding
Strukturert binding er en funksjon som gjør det mulig for navn å bli gitt til underobjekter. Følgende kode illustrerer dette for matrisen:
int arr [3] = 1, 2, 3;auto [x, y, z] (arr);
cout << x <<"<< y <<"<< z <<'\n';
Utgangen er 1 2 3. Så verdiene: 1, 2, 3 har fått navnene, x, y, z. Legg merke til bruken og plasseringen av det reserverte ordet, auto. Legg også merke til bruken av de firkantede parentesene.
Bit-felt
Minnet er en sekvens av celler. Hver celle tar en byte. Også hver byte består av åtte biter. En gruppe biter, ikke nødvendigvis åtte biter, kan settes og endres. En slik gruppe kalles litt felt. Disse gruppene ville ligge ved siden av hverandre. Hvis gruppene ikke vil utgjøre en type, si 16 biter for en kort INT, er polstringsbiter lagt til. Følgende kode illustrerer dette med strukturen:
struct dateusignert kort wkday: 3; // 3 biter
usignert kort mandag: 6; // 6 biter
usignert kort mon: 5; // 5 biter
usignert kort yr: 8; // 8 biter for 2 -sifret år
dte;
dte.wkday = 1; dte.Mandag = 2; dte.man = 2; dte.yr = 21;
cout << dte.mon <<'/'<< dte.monDay <<'/'<< dte.yr <<'\n';
Utgangen er: 2/2/21. Det totale antallet biter for WKDAY, Mandag og MON er 3 + 6 + 5 = 14. Så to polstringsbiter vil bli lagt til for å utgjøre 16 biter for det korte heltallet på 2 byte (16 biter). De neste 8 bitene begynner neste korte int, som deretter fylles opp med 8 polstringsbiter.
Merk: Unngå å bruke bitfelt; Bruk den bare til forskning.
Navneområde
Et navneområde er et sett med navn, som ikke skal komme i konflikt med de samme navnene på andre sett med navn. Følgende program illustrerer bruken av de samme navnene fra to forskjellige navneområder, brukt i hovedfunksjonens navneområde:
#inkludereved hjelp av navneområdet STD;
Navnområde NS1
int myint = 8;
float flt;
Navnområde NS2
int myint = 9;
float 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';
retur 0;
Utgangen er:
98
2.5
4.8
Det er to motstridende samme INT -navn og to motstridende samme flytnavn i koden.
Mal og malspesialisering
Malskjemaet tillater bruk av en plassholder for forskjellige mulige skalartyper. Spesialisering velger en bestemt skalær type. Følgende kode illustrerer dette for en funksjon:
#inkludereved hjelp av navneområdet STD;
mal
void func (t cha, u nei)
cout << "I need bread for " << cha << no << '.' << '\n';
int main ()
func ('$', 3);
retur 0;
Utgangen er:
Jeg trenger brød for $ 3.Malparameterpakke
Kompilatorer skal fremdeles implementere denne funksjonen - se senere.
Konklusjon
C ++ typer eksisterer i to kategorier: grunnleggende typer og sammensatte typer. Grunnleggende typer er skalartyper. Grunnleggende sammensatte typer er matriser, oppregninger, klasser, fagforeninger, referanser, tips og funksjoner. Disse grunnleggende sammensatte typene brukes til å konstruere utdypede sammensatte typer, som er typedef, strukturerte bindinger, bitfelt, navneområde og malfunksjoner.