C++-typen

Een C++-entiteit is een waarde, object, referentie, functie, enumerator, type, klasselid, bitveld, gestructureerde binding, naamruimte, sjabloon, sjabloonspecialisatie of parameterpakket. Een entiteit kan van een of meer typen zijn. Er zijn twee categorieën C++-typen: fundamentele en samengestelde typen. Een scalaire waarde is rekenkundig of een aanwijzerobjecttype. Fundamentele typen zijn scalairen, terwijl de rest van de entiteitstypen samengestelde typen zijn.

Het geheugen van een computer is een reeks cellen. Elke cel heeft de grootte van één byte, het is normaal gesproken de ruimte die wordt ingenomen door een West-Europees teken. De grootte van een object wordt gegeven in bytes. Dit artikel geeft een overzicht van C++-typen. U moet al basiskennis van C++ hebben om dit artikel te begrijpen.

Artikel Inhoud

- Fundamentele typen
- Manieren om samengestelde typen te construeren
- Arrays
- Opsomming
- Klasse
- Unie
- Referenties
- Functies
- Andere verbindingstypen
- Conclusie

Fundamentele typen

Fundamentele typen zijn scalaire typen.

bool

Een Boolean type of bool type heeft de waarde true of false voor 1 of 0. Waar of onwaar neemt één byte in beslag.

char, unsigned char en ondertekend char

Een char is typisch voor één West-Europees karakter. Het neemt meestal één byte in beslag. Er is ook een niet-ondertekende en ondertekende char, die elk een acht-bits geheel getal is. Niet-ondertekende tekens hebben geen negatieve waarden, terwijl ondertekende tekens negatieve waarden bevatten. Het soort waarde dat een char heeft, hangt af van de compiler en kan gewoon een niet-ondertekende char zijn. Deze drie typen tekens worden smalle tekentypen genoemd en nemen elk één byte in beslag.

Geheel getal

Er zijn vijf niet-ondertekende standaard integer-typen en vijf ondertekende standaard integer-typen. De vijf niet-ondertekende integer-typen zijn: "unsigned char", "unsigned short int", "unsigned int", "unsigned long int" en "unsigned long long int". De vijf corresponderende ondertekende integer-typen zijn: "signed char", "short int", "int", "long int" en "long long int".

"unsigned char" is hetzelfde type als de smalle tekentypes (zie hierboven). "signed char" is het andere type van de smalle tekentypes (zie hierboven).

Met de g++-compiler neemt "unsigned char" of "signed char" één byte in beslag; "unsigned short int" of "short int" neemt twee bytes in beslag; "unsigned int" of "int" neemt vier bytes in beslag; "unsigned long int" of "long int" neemt 8 bytes in beslag; "unsigned long long int" of "long long int" neemt nog steeds 8 bytes in beslag (vanaf nu).

char16_t, char32_t, wchar_t

Bij West-Europese karakters is het char-type in veel situaties voldoende. Als het echter om Chinese en andere oosterse talen gaat, is char16_t, of char32_t, of wchar_t nodig. Met de g++-compiler neemt char16_t twee bytes in beslag; char32_t neemt vier bytes in beslag en wchar_t neemt ook vier bytes in beslag.

De bool, de char, de char16_t, de char32_t, de wchar_t, de ondertekende en de niet-ondertekende integer-typen vormen een andere set, integrale (integer) typen genoemd.

Op dit punt in het artikel zijn twee collectieve typen genoemd: smalle tekentypen en integrale typen.

Typen met drijvende komma

Stel dat de getallen 457.000 en 457.230 dezelfde aflezing zijn, gemeten door twee verschillende meetinstrumenten. 457.230 is nauwkeuriger dan 457.000 omdat de waarde gedetailleerder is (betreft kleinere plaatsen: + 200 plus 30). Een getal met drijvende komma is een getal met een fractioneel (decimaal) deel. Hoewel getallen in de computer een reeks bits zijn, zijn sommige getallen met drijvende komma nauwkeuriger dan andere.

Sommige meetinstrumenten nemen metingen in minimale stappen, zeg 10 eenheden. Zo'n instrument zou de volgende waarden hebben: 10, 20, 30, 40,... 100, 110, 130, 140,... 200, 210, 220, 230, 240, enzovoort. Hoewel getallen in de computer een reeks bits zijn, variëren getallen met drijvende komma in enkele minimale stappen (veel kleiner dan 10 eenheden).

C++ heeft drie typen drijvende komma, namelijk: float, double en long double. Voor elke compiler moet double de precisie hebben die hoger is dan die van float of op zijn minst die van float; lange dubbele moet de precisie hebben die hoger is dan die van dubbel of op zijn minst die van dubbel.

Er is een derde verzamelnaam: rekentype. Dit is de naam voor typen integralen en drijvende komma's. Merk op dat dit ook de naam is voor alle scalaire typen, zoals tot nu toe uitgelegd explained.

Met de g++-compiler is het aantal bytes voor een float vier; het aantal bytes voor een dubbel is acht; het aantal bytes voor een long double is zestien.

leeg type:

Met de g++-compiler is de grootte van het void-type één byte. De byte heeft officieel geen bits, wat betekent dat de locatie lege inhoud heeft.

Manieren om samengestelde typen te construeren

Samengestelde typen zijn niet-fundamentele typen. Dit betekent dat samengestelde typen niet-scalaire typen zijn. In dit gedeelte worden de basisprincipes van samengestelde typen uitgelegd.

Arrays

Het volgende codesegment toont een reeks ints en een reeks tekens:

int arrInt[] = 1, 2, 3, 4, 5;
char arrCha[] = 'a', 'b', 'c', 'd', 'e';
cout << arrInt[2] <<" <De output is: 3 c.

Opsomming

Een opsomming is een type, met benoemde constanten. Overweeg het volgende codesegment:

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

De uitvoer is: 4. De eerste regel van het codesegment is een opsomming en a, b of c is een enumerator.

Klasse

Een klasse is een gegeneraliseerde eenheid waaruit veel objecten van dezelfde gegeneraliseerde eenheid kunnen worden gemaakt (geïnstantieerd). Het volgende programma toont een klasse en twee objecten, die daaruit zijn geïnstantieerd. Zo'n object is anders dan een scalair object.

#include
namespace std; gebruiken;
klasse TheCla

openbaar:
int aantal = 5;
int fn()

retournummer;

;
int hoofd()

DeCla obj1;
DeCla obj2;
cout << obj1.num << " << obj2.num <<'\n';
retourneer 0;

De uitvoer is: 5 5. De naam van de klasse is TheCla en de namen van de twee objecten zijn obj1 en obj2. Let op de puntkomma net na de beschrijving (definitie) van de klasse. Merk op hoe de twee objecten werden geïnstantieerd in de functie main().

Opmerking: num is een gegevenslid en fn is een lidfunctie.

Unie

structureren

Een struct is als een array, maar in plaats van index/waarde-paren heeft het naam/waarde-paren. De namen kunnen in willekeurige volgorde worden geschreven. Het volgende programma toont een structuur en het gebruik ervan:

#include
namespace std; gebruiken;
struct TheCla

int aantal = 5;
vlotter flt = 2.3;
char ch = 'een';
obj1, obj2;
int hoofd()

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

De uitvoer is:

5, 2.3, een

De naam van de structuur is TheCla. obj1 en obj2 zijn twee verschillende objecten van de struct.

Unie

Het volgende programma toont een vakbond en het gebruik ervan:

#include
namespace std; gebruiken;
vakbond TheCla

int. aantal;
vlotter flt = 2.3;
char ch;
obj1, obj2;
int hoofd()

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

De uitvoer is: 2.3. De unie is vergelijkbaar met een struct. Het belangrijkste verschil tussen een struct en een vakbond is dat voor een struct slechts één lid tegelijkertijd een waarde (geïnitialiseerd) kan hebben. In het bovenstaande programma heeft het lid, flt een waarde van 2.3. Elk van de andere leden, num of ch, kan alleen een waarde next hebben als de waarde voor flt wordt opgegeven.

Referenties

Een referentie is een synoniem voor een identifier. Het volgende codesegment laat zien hoe u een verwijzing naar een identifier kunt verkrijgen:

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

De uitvoer is: 5 5 5. ref1 en ref2 zijn synoniemen voor id.

lvalue-referentie en rvalu-referentie:

De bovenstaande referenties zijn waardereferenties. De volgende code toont de rvalue-referentie:

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

De uitvoer is: 5. Deze referentie wordt gemaakt zonder een locatie in het geheugen te identificeren. Om dit te bereiken is dubbel & nodig, i.e., &&.

Wijzer

Een aanwijzer is niet echt een C++-entiteit. Het biedt echter een beter schema voor het omgaan met referenties. De volgende code laat zien hoe een aanwijzer kan worden gemaakt:

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

De uitvoer is: 5. Let op het verschil in naam tussen ptdId en ptdId. ptdId is het puntige object en ptrId is het aanwijzerobject. &ptdId retourneert het adres van het puntige object dat is toegewezen aan ptrId. Gebruik *ptrId . om de waarde van het puntige object te retourneren.

Functies

Basisfunctie en zijn oproep

De volgende code toont een basisfunctiedefinitie en de aanroep:

#include
namespace std; gebruiken;
int fn(int num)

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

int hoofd()

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

De uitvoer is:

functiedefinitie

De functieaanroep is fn(5). De naam van de functie is fn.

Verwijzing en verwijzing naar een functie

&fn retourneert het adres in het geheugen van de functie waarvan de naam fn . is. De volgende instructie declareert een aanwijzer naar een functie:

int (*func)();

Hier is func de naam van de aanwijzer naar de functie. Het eerste paar haakjes onderscheidt deze functieaanwijzer van een scalaire objectaanwijzer. func kan als volgt worden gemaakt om het adres van een functie te bevatten die wordt geïdentificeerd door fn:

func = &fn;

Het volgende programma zet de functiereferentie en aanwijzer in actie:

#include
namespace std; gebruiken;
int fn(int num)

/* enkele uitspraken */
retournummer;

int hoofd()

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

De uitvoer is: 5. Merk op dat zowel fn als func elk de parameter int in de declaratie hebben.

Andere verbindingstypen

De bovenstaande basissamenstellingstypen zijn op zichzelf samengesteld. Ze worden ook gebruikt om uitgewerkte samengestelde typen te construeren.

typedef

Het gereserveerde woord typedef wordt gebruikt om een reeks typen te vervangen door één naam (voor de reeks). Het volgende codesegment illustreert dit:

typedef unsigned long int IduIL;

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

De uitvoer is 555555555555555555. In de code is IduIL een type geworden dat staat voor "unsigned long int".

Gestructureerde binding

Gestructureerde binding is een functie die het mogelijk maakt om namen te geven aan subobjecten. De volgende code illustreert dit voor de array:

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

De uitvoer is 1 2 3. Dus de waarden: 1, 2, 3 hebben de namen x, y, z . gekregen. Let op het gebruik en de positie van het gereserveerde woord, auto. Let ook op het gebruik van de vierkante haken.

Bit-veld

Het geheugen is een opeenvolging van cellen. Elke cel heeft een byte. Elke byte bestaat ook uit acht bits. Een groep bits, niet noodzakelijk acht bits, kan worden ingesteld en gewijzigd. Zo'n groep wordt een bitveld genoemd. Deze groepen zouden naast elkaar liggen. Als de groepen geen type vormen, zeg 16 bits voor een korte int, worden opvulbits toegevoegd. De volgende code illustreert dit met de struct:

struct Datum:

ongetekende korte weekdag : 3; //3 bits
ongetekende korte maandag : 6; //6 bits
ongetekende korte ma : 5; //5 bits
ongetekend kort jr : 8; //8 bits voor 2-cijferig jaar
dte;
dte.weekdag = 1; dte.maandag = 2; dte.ma = 2; dte.jaar = 21;
cout << dte.mon <<'/'<< dte.monDay <<'/'<< dte.yr <<'\n';

De uitvoer is: 2/2/21. Het totale aantal bits voor wkDay, MonDay en ma is 3 + 6 + 5 = 14. Er zouden dus twee opvulbits worden toegevoegd om 16 bits te vormen voor het korte gehele getal van 2 bytes (16 bits). De volgende 8 bits beginnen met de volgende korte int, die vervolgens wordt opgevuld met 8 opvulbits.

Opmerking: Vermijd het gebruik van bitvelden; gebruik het alleen voor onderzoek.

Naamruimte

Een naamruimte is een reeks namen, die niet in strijd mag zijn met dezelfde namen van andere reeksen namen. Het volgende programma illustreert het gebruik van dezelfde namen uit twee verschillende naamruimten, toegepast in de naamruimte van de functie main():

#include
namespace std; gebruiken;
naamruimte NS1

int mijnInt = 8;
vlotter flt;

naamruimte NS2

int mijnInt = 9;
vlotter flt;

int hoofd()

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

De uitvoer is:

2.5

4.8

Er zijn twee conflicterende dezelfde int-namen en twee conflicterende dezelfde float-namen in de code.

Sjabloon en sjabloonspecialisatie

Het sjabloonschema maakt het gebruik van een tijdelijke aanduiding voor verschillende mogelijke scalaire typen mogelijk. Specialisatie is het kiezen van een bepaald scalair type. De volgende code illustreert dit voor een functie:

#include
namespace std; gebruiken;
sjabloon void func (T cha, U no)

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

int hoofd()

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

De uitvoer is:

"Ik heb brood nodig voor $ 3".”

Sjabloonparameterpakket

Compilers moeten deze functie nog steeds volledig implementeren - zie later.

Conclusie

C++-typen bestaan in twee categorieën: fundamentele typen en samengestelde typen. Fundamentele typen zijn scalaire typen. Basis samengestelde typen zijn arrays, opsommingen, klassen, vakbonden, verwijzingen, pointers en functies. Deze elementaire samengestelde typen worden gebruikt om uitgebreide samengestelde typen te construeren, namelijk typedef, gestructureerde bindingen, bitvelden, naamruimte en sjabloonkenmerken.

Chrys