C ++ -typer

En C ++ -enhet är ett värde, objekt, referens, funktion, enumerator, typ, klassmedlem, bitfält, strukturerad bindning, namnrymd, mall, mallspecialisering eller parametrar. En enhet kan vara av en eller flera typer. Det finns två kategorier av C ++ - typer: grundläggande och sammansatta typer. En skalär är aritmetik eller en pekartyp. Grundläggande typer är skalar, medan resten av enhetstyperna är sammansatta typer.

Minnet på en dator är en serie celler. Varje cell har storleken på en byte, det är normalt det utrymme som upptas av en västeuropeisk karaktär. Storleken på ett objekt anges i byte. Den här artikeln ger en sammanfattning av C ++ - typer. Du bör redan ha grundläggande kunskaper om C ++ för att förstå den här artikeln.

Artikelinnehåll

- Grundläggande typer
- Sätt att konstruera föreningstyper
- Arrayer
- Uppräkning
- Klass
- Union
- Referenser
- Funktioner
- Andra föreningstyper
- Slutsats

Grundläggande typer

Grundläggande typer är skalära typer.

bool

En boolsk typ eller booltyp har värdet true eller false för 1 eller 0. Sann eller falsk upptar en byte.

röding, osignerad röding och signerad röding

En röding är typiskt för en västeuropeisk karaktär. Det upptar vanligtvis en byte. Det finns också en osignerad och signerad char, som var och en är ett åtta-bitars heltal. Osignerade tecken innehåller inte negativa värden, medan signerade tecken innehåller negativa värden. Vilken typ av värde en rödhet har beror på kompilatorn och kan bara vara en osignerad röd. Dessa tre typer av tecken kallas smala karaktärstyper och upptar var och en en byte.

Heltal

Det finns fem osignerade standardtal och fem signerade standardtal. De fem osignerade heltalstyperna är: "osignerad char", "unsigned short int", "unsigned int", "unsigned long int" och "unsigned long long int". De fem motsvarande signerade heltalstyperna är: "signerad char", "short int", "int", "long int" och "long long int".

"Osignerad char" är av samma typ som de smala teckentyperna (se ovan). "Signerad char" är den andra typen av smala karaktärstyper (se ovan).

Med g ++ -kompilatorn upptar "osignerad char" eller "signerad char" en byte; "Osignerad kort int" eller "kort int" upptar två byte; ”Unsigned int” eller “int” upptar fyra byte; ”Unsigned long int” eller “long int” upptar 8 byte; ”Unsigned long long int” eller “long long int” upptar fortfarande 8 byte (från och med nu).

char16_t, char32_t, wchar_t

När man handlar om västeuropeiska karaktärer räcker char-typen i många situationer. Men när man behandlar kinesiska och andra östliga språk behövs char16_t eller char32_t eller wchar_t. Med g ++ kompilatorn upptar char16_t två byte; char32_t upptar fyra byte och wchar_t upptar också fyra byte.

Bool, char, char16_t, char32_t, wchar_t, signerad och osignerade heltalstyper, bildar en annan uppsättning, som kallas integrala (heltal) typer.

Vid denna punkt i artikeln har två kollektiva typer nämnts: smala karaktärstyper och integraltyper.

Flytpunkttyper

Antag att siffrorna 457 000 och 457 230 är samma avläsning, mätt med två olika mätinstrument. 457,230 är mer exakt än 457,000 eftersom värdet är mer detaljerat (involverar mindre platser: + 200 plus 30). Ett flytpunktsnummer är ett tal med en bråkdel (decimal) del. Även om siffror i datorn är en sekvens av bitar, är vissa flytpunktsnummer mer exakta än de andra.

Vissa mätinstrument gör mätningar i minsta steg, säg 10 enheter. Ett sådant instrument skulle ha följande avläsningar: 10, 20, 30, 40, ... 100, 110, 130, 140, ... 200, 210, 220, 230, 240, och så vidare. Även om siffror i datorn är en sekvens av bitar, varierar siffror med flytande punkter i vissa minimisteg (mycket mindre än 10 enheter).

C ++ har tre flytpunkttyper, vilka är: float, double och long double. För varje kompilator måste dubbel ha den precision som är högre än för flottör eller åtminstone för flottör; lång dubbel måste ha precisionen som är högre än dubbel eller åtminstone den för dubbel.

Det finns ett tredje samlingsnamn: aritmetisk typ. Detta är namnet på integrerade och flytande punkttyper. Observera att detta också är namnet på alla skalartyper, som förklarats hittills.

Med g ++ -kompilatorn är antalet byte för en flottör fyra; antalet byte för en dubbel är åtta; antalet byte för en lång dubbel är sexton.

ogiltig typ

Med g ++ -kompilatorn är tomrumstypens storlek en byte. Byten har officiellt inga bitar, vilket innebär att dess plats har tomt innehåll.

Sätt att konstruera föreningstyper

Föreningstyper är icke-grundläggande typer. Detta innebär att föreningstyper är icke-skalära typer. Detta avsnitt förklarar grunderna för sammansatta typer.

Arrayer

Följande kodsegment visar en rad inter och en rad med tecken:

int arrInt [] = 1, 2, 3, 4, 5;
char arrCha [] = 'a', 'b', 'c', 'd', 'e';
cout << arrInt[2] <<" <Utgången är: 3 c.

Uppräkning

En uppräkning är en typ med namngivna konstanter. Tänk på följande kodsegment:

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

Utgången är: 4. Den första raden i kodsegmentet är en uppräkning, och a, b eller c är en uppräkare.

Klass

En klass är en generaliserad enhet från vilken många objekt av samma generaliserade enhet kan skapas (instansierad). Följande program visar en klass och två objekt, instanserade från den. Ett sådant objekt skiljer sig från ett skalärt objekt.

#omfatta
använder namnrymd std;
klass TheCla

offentlig:
int num = 5;
int fn ()

returnummer;

;
int main ()

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

Utgången är: 5 5. Klassens namn är TheCla och namnen på de två objekten är obj1 och obj2. Observera semikolon strax efter beskrivningen (definition) av klassen. Observera hur de två objekten instantierades i huvudfunktionen ().

Obs: num är en datamedlem och fn är en medlemsfunktion.

Union

struct

En struktur är som en matris men istället för att ha index / värde-par har den namn / värde-par. Namnen kan skrivas i valfri ordning. Följande program visar en struktur och dess användning:

#omfatta
använder namnrymd 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';
returnera 0;

Utgången är:

5, 2.3, a

Namnet på strukturen är TheCla. obj1 och obj2 är två olika objekt för strukturen.

Union

Följande program visar en fackförening och dess användning:

#omfatta
använder namnrymd std;
fackförening TheCla

int num;
float flt = 2.3;
char ch;
obj1, obj2;
int main ()

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

Utgången är: 2.3. Facket liknar en struktur. Huvudskillnaden mellan en struktur och en union är att för en struct kan endast en medlem ha ett värde (initialiserat) åt gången. I ovanstående program har medlemmen flt ett värde på 2.3. Var och en av de andra medlemmarna, num eller ch, kan bara ha ett värde nästa om värdet för flt överges.

Referenser

En referens är en synonym för en identifierare. Följande kodsegment visar hur man får en referens till en identifierare:

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

Utgången är: 5 5 5. ref1 och ref2 är synonymer till id.

lvalue Reference och rvalue Reference

Ovanstående referenser är referensvärden. Följande kod visar referensvärde:

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

Utgången är: 5. Denna referens skapas utan att någon plats i minnet identifieras. För att uppnå detta krävs dubbel &, dvs.e., &&.

Pekare

En pekare är egentligen inte en C ++ -enhet. Det ger dock ett bättre schema för hantering av referenser. Följande kod visar hur en pekare kan skapas:

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

Utgången är: 5. Notera skillnaden i namn mellan ptdId och ptdId. ptdId är det spetsiga objektet och ptrId är pekarobjektet. & ptdId returnerar adressen till det spetsiga objektet som tilldelas ptrId. Använd * ptrId för att returnera värdet för det spetsiga objektet.

Funktioner

Grundläggande funktion och dess samtal

Följande kod visar en grundläggande funktionsdefinition och dess samtal:

#omfatta
använder namnrymd std;
int fn (int num)

cout<<"seen"<<'\n';
returnummer;

int main ()

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

Utgången är

funktionsdefinition

Funktionsanropet är fn (5). Funktionens namn är fn.

Referens och pekare till en funktion

& fn returnerar adressen i minnet för den funktion vars namn är fn. Följande uttalande förklarar en pekare till en funktion:

int (* func) ();

Här är funk namnet på pekaren till funktionen. Det första paret inom parentes skiljer denna funktionspekare från en skalär objektpekare. funk kan göras för att hålla adressen till en funktion som identifieras av fn, enligt följande:

func = &fn;

Följande program sätter funktionsreferensen och pekaren i handling:

#omfatta
använder namnrymd std;
int fn (int num)

/ * några uttalanden * /
returnummer;

int main ()

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

Utgången är: 5. Observera att både fn och func har vardera int-parametern i deklarationen.

Andra föreningstyper

Ovanstående basföreningstyper är sammansatta i sig själva. De används också för att konstruera utarbetade föreningstyper.

typedef

Det typedef reserverade ordet används för att ersätta en sekvens av typer med ett namn (för sekvensen). Följande kodsegment illustrerar detta:

typedef osignerad lång int IdIL;

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

Utgången är 555555555555555555. I koden har IduIL blivit en typ som står för "unsigned long int".

Strukturerad bindning

Strukturerad bindning är en funktion som gör det möjligt för namn att ges till underobjekt. Följande kod illustrerar detta för arrayen:

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

Utgången är 1 2 3. Så, värdena: 1, 2, 3 har fått namnen, x, y, z. Observera användningen och placeringen av det reserverade ordet, auto. Notera också användningen av hakparenteserna.

Bit-fält

Minnet är en sekvens av celler. Varje cell tar en byte. Varje byte består också av åtta bitar. En grupp bitar, inte nödvändigtvis åtta bitar, kan ställas in och ändras. En sådan grupp kallas ett bitfält. Dessa grupper skulle ligga bredvid varandra. Om grupperna inte utgör en typ, säg 16 bitar för en kort int, läggs paddingbitar till. Följande kod illustrerar detta med strukturen:

struct Datum

osignerad kort wkDay: 3; // 3 bitar
osignerad kort måndag: 6; // 6 bitar
osignerad kort mån: 5; // 5 bitar
osignerad kort år: 8; // 8 bitar för tvåsiffrigt år
dte;
dte.wkDay = 1; dte.måndag = 2; dte.mon = 2; dte.yr = 21;
cout << dte.mon <<'/'<< dte.monDay <<'/'<< dte.yr <<'\n';

Utgången är: 2/2/21. Det totala antalet bitar för wkDay, MonDay och mon är 3 + 6 + 5 = 14. Så skulle två stoppningsbitar läggas till för att göra upp 16 bitar för det korta heltalet om 2 byte (16 bitar). De nästa åtta bitarna börjar nästa korta int, som sedan fylls med åtta stoppningsbitar.

Obs! Undvik att använda bitfält; använd den bara för forskning.

Namnområde

Ett namnområde är en uppsättning namn som inte bör strida mot samma namn på andra uppsättningar namn. Följande program illustrerar användningen av samma namn från två olika namnområden, applicerade i huvudfunktionens namnområde:

#omfatta
använder namnrymd std;
namnområde NS1

int mynt = 8;
float flt;

namnområ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';
returnera 0;

Utgången är:

2.5

4.8

Det finns två motstridiga samma int-namn och två motstridiga samma float-namn i koden.

Mall och mall specialisering

Mallschemat tillåter användning av en platshållare för olika möjliga skalartyper. Specialisering är att välja en viss skalartyp. Följande kod illustrerar detta för en funktion:

#omfatta
använder namnrymd std;
ogiltig mall (T cha, U no)

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

int main ()

funk ('$', 3);
returnera 0;

Utgången är:

”Jag behöver bröd för $ 3.”

Mallparameterpaket

Kompilatorer ska fortfarande implementera den här funktionen - se senare.

Slutsats

C ++ typer finns i två kategorier: grundläggande typer och sammansatta typer. Grundläggande typer är skalära typer. Grundläggande sammansatta typer är matriser, uppräkningar, klasser, fackföreningar, referenser, pekare och funktioner. Dessa grundläggande föreningstyper används för att konstruera utarbetade föreningstyper, som är typedef, strukturerade bindningar, bitfält, namnområde och mallfunktioner.

Chrys