C ++ størrelse av

Størrelsen () er en operatør i C++. Det er en unarisk operatør som hjelper programmererne med å bestemme størrelsen på operandene de bruker. En integrert type, vanligvis betegnet med størrelse “T”, er resultatet av denne operatøren. Denne operatøren brukes vanligvis med primitive datatyper som heltall, float, peker osv. I tillegg kan det gi størrelsen på en mer sofistikerte datatyper som fagforeninger og strukturer. Det er en operatør som kan beregne størrelsen på operanden og bestemme størrelsen på hvilken som helst datatype ved kompileringstidspunktet. Størrelsen er mengden RAM som brukes av datamaskinen og bestemmes av størrelsen () -operasjonen.

Syntaks for størrelsen på () operatøren i C++

Følgende beskriver syntaks for størrelsen på () -operatøren:

# sizeof (navn på data_type);

Når den brukes med den første typen objekt, gir størrelsen () -funksjonen objektets størrelse i byte for typen objekt som sendes. Størrelsen på varen som er i typen uttrykk, målt i byte, er den andre typen. Etter at uttrykket er vurdert, forblir størrelsen den samme.

Eksempel 1:

Når datatypene som Int, Float, Char, etc. brukes med størrelsen på () operatøren, funksjonen gir bare mengden RAM som er tildelt den aktuelle datatypen.

#inkludere
ved hjelp av navneområdet STD;
int main ()

std :: cout << "Size of data type int : " <std :: cout << "Size of data type float : " <std :: cout << "Size of data type double: " <std :: cout << "Size of data type char: " <retur 0;

Ved å bruke størrelsen på () operatøren med COUT-kommandoen, evaluerer vi størrelsen på de innebygde datatypene i den nevnte applikasjonen. Som vi kan se i følgende utgang, gir størrelsen () -operasjonen det samme svaret som vi forventer gitt vår kunnskap om byte -størrelsene på int, float, dobbel og røye.

Eksempel 2:

Programmet, når en klassetype er operand, bruker størrelsen på () -operatøren. Her er en illustrasjon:

#inkludere
ved hjelp av navneområdet STD;
Klasse mybase_class

int x;
;
int main ()

Mybase_class y;
std :: cout << "Size of Base class is : "<retur 0;

Med bare ett heltallvariabel “X” i klassen “MyBase_Class” og den nevnte skriptets hovedmetode, evaluerer vi klassens størrelse. Først kaller vi den gitte klassen og lager objektet som "y". Deretter har vi en størrelse av () operatør som tar "y" som innspill. Heltallvariablene tar opp 4 byte, så utfallet ville være 4 byte som trykt i følgende:

Eksempel 3:

Hvis vi øker antall heltallvariabler i en klasse, produseres følgende kode:

#inkludere
ved hjelp av navneområdet STD;
Klasse MyClass_Base

int jeg;
int j;
;
int main ()

Myclass_base j;
std :: cout << "Size of MyClass_Base is : "<retur 0;

Det er nå en andre heltallvariabel “J” i forrige kode. Gitt at INT -variabelen tar opp 4 byte og det er to heltallvariabler som "i" og "j", er "myclass_base" -klassen i dette scenariet 8 byte i størrelse.

Eksempel 4:

Koden kan ligne følgende hvis vi inkluderer en røyevariabel:

#inkludere
ved hjelp av navneområdet STD;
klasse Myclass

int p;
int q;
char ch;
;
int main ()

MyClass Q;
std :: cout << "Size of MyClass is : "<retur 0;

To heltall og en char -variabel brukes i "MyClass" -klassens forrige kode. Størrelsen på klassen skal være 9 byte, da det er tre datatyper (int+int+røye) i henhold til beregningene våre. Men dette er feil på grunn av ideen om strukturpolstring. Du kan se følgende resultatverdi:

Eksempel 5:

Saken der operanden er en matrise. La oss se på programimplementeringen:

#inkludere
ved hjelp av navneområdet STD;
int main ()

int arr_set [] = 5,15,25,35,45;
std :: cout << "Size of the 'arr_set' is : "<retur 0;

Vi etablerte en heltallstype som "arr_set" med fem elementer i forrige program. Vi bestemte matrisens størrelse ved å bruke størrelsen () operatøren. Arrayen er 20 byte i størrelse, ettersom INT -datatypen tar opp 4 byte og det er 5 oppføringer i matrisen, noe. Som vi kan se i følgende utgang, ga størrelsen () -operasjonen det samme resultatet.

Eksempel 6:

Eksemplet har allerede størrelsen på matrisen. La oss vurdere en rekke fra et bestemt perspektiv.

#inkludere
ved hjelp av navneområdet STD;
void new_function (int array [])

std :: cout << "Size of array is : " <
int main ()

int array [] = 51,52,53,54,55;
new_function (array);
retur 0;

Vi prøvde å bruke "new_function" -funksjonen i den nevnte applikasjonen for å skrive ut arrayens størrelse. Vi dannet en heltall-type matrise i dette tilfellet, og vi sender "matrisen" -parameteren til New_Function (). Størrelsen på heltallpekeren eller int* returneres av New_Function (). I 64-biters operativsystemer er størrelsen på int* 8 byte. Utgangen genererer matrisestørrelsen som følger:

Eksempel 7:

Nå er dette eksemplet der argumentet er av typen peker inne i størrelsen () operatøren.

#inkludere
ved hjelp av navneområdet STD;
int main ()

int *ptr1 = ny int (31);
std :: cout << "ptr1 size:" <std :: cout << "*ptr1 size :" <dobbel *ptr2 = ny dobbel (20.99);
std :: cout <<"ptr2 size :" <std :: cout <<" *ptr2 size :"<char *ptr3 = new char ('m');
std :: cout <<"ptr3 size :" <std :: cout <<"*ptr3 size :"<retur 0;

Vi beregnet størrelsen på pekere i manuset som er nevnt i tidligere. For datatypene "int", "dobbelt" og "røye", forblir pekerstørrelsene konstante. Størrelsen på pekeren er 4 byte hvis datamaskinen hadde et 32-biters operativsystem. Størrelsen på pekeren er 8 byte hvis datamaskinen kjører et 64-biters operativsystem. Resultatet er 8 byte når vi utfører dette skriptet på en 64-biters plattform. Nå, hvis vi gir pekeren symbolet “*”, endres utgangen avhengig av datatypen. For eksempel, hvis *PTR1 er en heltallstype, gir størrelsen () -operatøren 4 byte fordi en int -datatype tar opp 4 byte. Følgende er den resulterende størrelsen på pekere som tilsvarer hver spesifiserte datatype:

Eksempel 8:

Eksemplet der vi har et uttrykk som en størrelsesoperand.

#inkludere
ved hjelp av navneområdet STD;
int main ()

int integer_1;
dobbelt heltall_2;
cout << "size of int and double: " <retur 0;

Vi har to variabler, henholdsvis INTEGER_1 og INTEGER_2, av INT- og DOUBLE -typene. De er erklært i programmet. Som vi vet, er heltall 4 byte i størrelse mens dobler er 8 byte. Vi la til begge i størrelsen på () operatøren. Variabelen, dobbelt med en 8-byte størrelse, er utfallet.

Konklusjon

En størrelse av () forklaring på C ++ ender her. Vi har gått over detaljene om hvordan operatøren C ++ størrelse () opererer, sammen med relevante eksempler. Hvilken som helst datatype, uttrykk, matrise osv. kan ha sin størrelse bestemt ved hjelp av størrelsen () operatøren. Datatypen eller et uttrykk må gis som en del av argumentet. Og funksjonen returnerer størrelsen på den datatypen i byte som resultat.