Grootte van operator in C-taal

In dit artikel gaan we leren over de operator sizeof in C. Het is een veelgebruikte unaire operator in de ontwikkeling van embedded software, wat ons helpt de grootte van de operand te achterhalen. Daarom helpt de geretourneerde waarde van de operator sizeof ons om het aantal bytes te begrijpen dat in het computergeheugen is toegewezen om de specifieke variabele of het gegevenstype te bevatten.

Grootte van begrijpen:

Voordat we ingaan op de discussie over de grootte van de operator, laten we eerst de betekenis van de operator begrijpen:. Een operator wordt weergegeven door een token of symbool dat wordt gebruikt om een bewerking uit te voeren, zoals optellen, aftrekken, vermenigvuldigen, delen, enz. op waarden of variabelen (operanden). "*" is bijvoorbeeld het symbool dat wordt gebruikt om de vermenigvuldigingsbewerking weer te geven, en het werkt op twee operanden (resultaat = a * b;). Dit is een voorbeeld van een binaire operator.

Als een operator echter op slechts één operand werkt, noemen we een dergelijke operator een unaire operator. De operator sizeof is een van de unaire operatoren die in de C-programmeertaal bestaan en blijkbaar werkt het slechts op één operand. De operator sizeof retourneert de grootte van de operand. Dat betekent dat we uit de geretourneerde waarde van de operator Sizeof duidelijk kunnen zeggen hoeveel bytes zijn toegewezen om de specifieke operand in het computergeheugen vast te houden.

Het geheugen van een computer is een verzameling geheugeneenheden (i.e. byte). Wanneer sizeof (int) vier retourneert in een bepaald computersysteem, kunnen we zeggen dat een integer-variabele 4 bytes nodig heeft om zijn waarde vast te houden in het geheugen van dat specifieke computersysteem. Houd er ook rekening mee dat de geretourneerde waarde van de operator sizeof ook afhangt van de machines die u gebruikt (32-bits systeem of 64-bits systeem).

Syntaxis:

Grootte van (type)
Grootte van (uitdrukking)

Het retourtype van sizeof is size_t.

Voorbeelden:

Nu we de operator sizeof begrijpen en de syntaxis kennen, laten we een paar voorbeelden bekijken, die ons zullen helpen het concept op een betere manier te begrijpen.

Sizeof voor ingebouwde typen (voorbeeld1.c)
Grootte van voor array (voorbeeld2.c)
Sizeof voor door de gebruiker gedefinieerde typen (voorbeeld3.c)
Sizeof voor variabelen (voorbeeld4.c)
Sizeof voor expressie (voorbeeld5.c)
Praktisch gebruik van sizeof (voorbeeld6.c)

Sizeof voor ingebouwde typen (voorbeeld1.c):

In dit programma zullen we zien hoe de operator sizeof werkt voor ingebouwde gegevenstypen zoals int, char, float, double. Laten we eens kijken naar het programma en de output.

#include
int hoofd()

printf("Grootte van char = %ld \n", sizeof(char));
printf("Grootte van int = %ld \n", sizeof(int));
printf("Grootte van float = %ld \n", sizeof(float));
printf("Grootte van double = %ld \n\n", sizeof(double));
printf("Grootte van short int = %ld \n", sizeof(short int));
printf("Grootte van long int = %ld \n", sizeof(long int));
printf("Grootte van long long int = %ld \n", sizeof(long long int));
printf("Grootte van long double = %ld \n", sizeof(long double));
retourneer 0;

Grootte van voor array (voorbeeld2.c)

In dit programma zullen we zien hoe we de operator sizeof kunnen gebruiken voor verschillende soorten arrays. In het geval van een array, retourneert de operator sizeof (Nee. van elementen in de array * Sizeof (arraytype)). Als we bijvoorbeeld een array van het type integer van 10 elementen declareren (int SmartPhones [10] ;), dan zal de sizeof(Smartphones) als resultaat geven:

(Nee. van elementen in SmartPhones * sizeof(int)) = (10 * 4) = 40

Laten we eens kijken naar het programma en de output.

#include
int hoofd()

int Smartphones[10];
char SmartPhone-namen [10];
dubbele SmartPhonesPrijs[10];
printf("Grootte van int = %ld \n", sizeof(int));
printf("Grootte van char = %ld \n", sizeof(char));
printf("Grootte van double = %ld \n", sizeof(double));
/* Ontdek de grootte van Array*/
printf("Grootte van smartphones[10] = %ld \n", sizeof(SmartPhones));
printf("Grootte van SmartPhoneNamen[10] = %ld \n", sizeof(SmartPhoneNames));
printf("Grootte van SmartphonesPrijs[10] = %ld \n", sizeof(SmartPhonesPrijs));
retourneer 0;

Sizeof voor door de gebruiker gedefinieerde typen (voorbeeld3.c):

In dit voorbeeld zullen we zien hoe de operator sizeof kan worden gebruikt voor door de gebruiker gedefinieerde gegevenstypen zoals structuur en unie. Laten we het programma gebruiken en de uitvoer begrijpen.

Als we nu naar het programma kijken, kunnen we handmatig de grootte van SmartPhoneType berekenen. Zoals je hieronder kunt zien, is SmartPhoneType een structuur en bevat het de volgende elementen:

Aantal karaktertypevariabele = 1 [sp_name]
Aantal integer type variabele = 1 [sp_version]
Aantal variabelen van het type float = 3 [sp_length, sp_width, sp_height]

Uit voorbeeld-1 hebben we gezien dat:

- Grootte van het teken is 1 byte
- Grootte van een geheel getal is 4 bytes
- Grootte van een float is 4 bytes

Daarom, als we de grootte van alle elementen in de structuur bij elkaar optellen, zouden we in staat moeten zijn om de grootte van de structuur te krijgen, i.e. Type smartphone. Daarom moet de grootte van de structuur = (1 + 4 + 4 + 4 + 4) bytes = 17 bytes zijn. De programma-uitvoer zegt echter dat de structuurgrootte 20 . is. De extra 3 bytes (sp_name, dat een teken is, neemt 4 bytes in plaats van 1 byte) toegewezen aan de structuur vanwege de structuuropvulling.

#include
/* Maak een door de gebruiker gedefinieerd structuurtype - SmartPhoneType*/
struct SmartPhoneType

char sp_naam;
int sp_version;
float sp_length;
zweven sp_width;
zweven sp_height;
Smartphone;
/* Definieer een door de gebruiker gedefinieerd unietype - SmartPhoneUnionType*/
Union SmartPhoneUnionType

char sp_naam;
int sp_version;
float sp_length;
float sp_width;
zweven sp_height;
Smartphone_u;
int hoofd()

/* Ontdek de grootte van structuur en unie*/
printf("Grootte van structuur = %ld \n", sizeof(SmartPhone));
printf("Grootte van unie = %ld \n", sizeof(SmartPhone_u));
retourneer 0;

Sizeof voor variabelen (voorbeeld4.c):

Dit voorbeeldprogramma illustreert dat de operator sizeof in staat is om de variabele ook te accepteren en de grootte van de variabele terug te geven.

#include
int hoofd()

/* Declareer char, int, float en double type variabele en array */
char var_a, var_b[20];
int var_c, var_d[20];
float var_e, var_f[20];
dubbele var_g, var_h[20];
/* Ontdek de grootte van variabelen en array.
Dit programma laat zien dat variabele ook kan
worden gebruikt als een operand sizeof operator*/
/* grootte van char, char variabele en char array*/
printf("Grootte van char = %ld \n", sizeof(char));
printf("Grootte van var_a = %ld \n", sizeof(var_a));
printf("Grootte van var_b[20] = %ld \n\n", sizeof(var_b));
/* grootte van int, int variabele en int array*/
printf("Grootte van int = %ld \n", sizeof(int));
printf("Grootte van var_c = %ld \n", sizeof(var_c));
printf("Grootte van var_d[20] = %ld \n\n", sizeof(var_d));
/* grootte van float, float variabele en float array*/
printf("Grootte van float = %ld \n", sizeof(float));
printf("Grootte van var_e = %ld \n", sizeof(var_e));
printf("Grootte van var_f[20] = %ld \n\n", sizeof(var_f));
/* grootte van dubbele, dubbele variabele en dubbele array*/
printf("Grootte van double = %ld \n", sizeof(double));
printf("Grootte van var_g = %ld \n", sizeof(var_g));
printf("Grootte van var_h[20] = %ld \n", sizeof(var_h));
retourneer 0;

Grootte van voor expressie (voorbeeld5.c):

In dit voorbeeldprogramma laten we zien dat de operator sizeof ook een uitdrukking kan accepteren en de grootte van de resulterende uitdrukking kan teruggeven.

#include
int hoofd()

int var_a = 5, var_b = 3;
dubbele var_c = 2.5, var_d = 4.5;
printf("Grootte van int = %ld \n", sizeof(int));
printf("Grootte van double = %ld \n\n", sizeof(double));
printf("Grootte van var_a * var_b = %ld \n", sizeof(var_a * var_b));
printf("Grootte van var_c * var_d = %ld \n", sizeof(var_c * var_d));
/* Hier vermenigvuldigen we een integer-variabele met een dubbele variabele.
De operator sizeof retourneert daarom de grootte van de maximale grootte
variabele i.e. dubbele type variabele.*/
printf("Grootte van var_a * var_c = %ld \n", sizeof(var_a * var_c));
retourneer 0;

Praktisch gebruik van sizeof (voorbeeld6.c):

Dit voorbeeldprogramma helpt u een praktisch gebruiksscenario van de operator sizeof te begrijpen. De operator Sizeof is erg handig bij het toewijzen van het dynamische geheugen van de heap met behulp van malloc. Laten we eens kijken naar het programma en de output.

#include
#include
typedef-struct

char sp_naam;
int sp_version;
float sp_length;
zweven sp_width;
zweven sp_height;
SmartphoneType;
int hoofd()

/* Wijs geheugen toe aan het Heap-geheugen voor vijf SmartPhoneTypes
variabelen.
*/
SmartPhoneType * SmartPhone_Ptr = (SmartPhoneType *) malloc (5 * sizeof(SmartPhoneType));
if(SmartPhone_Ptr != NUL)

printf("Geheugen toegewezen voor 5 SmartPhoneType-structuurvariabelen in
het Heap-geheugen.\n");

anders

printf("Er is een fout opgetreden tijdens de toewijzing van het heapgeheugen!");

retourneer 0;

Conclusie:

De Sizeof is een belangrijke unaire operator in de programmeertaal C. Het helpt ons bij het bepalen van de grootte van primitieve gegevenstypen, door de gebruiker gedefinieerde gegevenstypen, uitdrukkingen, enz. in computergeheugen. De operator Sizeof speelt een belangrijke rol bij het toewijzen van dynamisch geheugen in C met behulp van malloc, calloc, enz. in het Heap-geheugen.