Operátor mérete C nyelven

Ebben a cikkben megismerjük a C operátor méretét. A beágyazott szoftverek fejlesztésében széles körben alkalmazott unáris operátor, amely segít megismerni az operandus méretét. Ezért a sizeof operátor visszatérési értéke segít megérteni a számítógép memóriájában lefoglalt bájtok számát az adott változó vagy adattípus megtartásához.

A Sizeof megértése:

Mielőtt belevetnénk magunkat az operátor beszélgetésbe, először értsük meg az operátor jelentését. Az operátort egy token vagy szimbólum képviseli, amelyet olyan művelet végrehajtására használnak, mint az összeadás, kivonás, szorzás, osztás stb. értékeken vagy változókon (operandusok). Például a „*” az a szimbólum, amelyet a szorzási művelet jelent, és két operanduson működik (eredmény = a * b;). Ez egy példa egy bináris operátorra.

Ha azonban egy operátor csak egy operanduson dolgozik, akkor ezt az operátort unariás operátornak hívjuk. A sizeof operátor egyike a C programozási nyelvben létező unáris operátoroknak, és nyilvánvalóan csak egy operanduson működik. A sizeof operátor visszaadja az operandus méretét. Ez azt jelenti, hogy a Sizeof operátor visszatérési értékéből egyértelműen meg tudjuk mondani, hogy hány bájt van allokálva az adott operandus megtartására a számítógép memóriájában.

A számítógép memóriája memóriaegységek gyűjteménye (azaz.e. byte). Amikor a sizeof (int) négyet ad vissza egy adott számítógépes rendszerben, akkor azt mondhatjuk, hogy egy egész változó 4 bájtot vesz igénybe, hogy megtartsa értékét az adott számítógépes rendszer memóriájában. Kérjük, vegye figyelembe, hogy az operátor size visszatérési értéke az Ön által használt gépektől is függ (32 bites vagy 64 bites rendszer).

Szintaxis:

Méret (típus)
(Kifejezés) mérete

A sizeof visszatérési típusa size_t.

Példák:

Most, hogy értjük az operátor méretét és ismerjük a szintaxist, nézzünk meg néhány példát, amelyek segítenek a koncepció jobb megértésében.

• Beépített típusok mérete (példa1.c)
• A tömb mérete (példa2.c)
• Sizeof a felhasználó által definiált típusokhoz (példa3.c)
• A változók mérete (példa4.c)
• Kifejezés mérete (példa5.c)
• A sizeof gyakorlati használata (példa6.c)

Beépített típusok mérete (példa1.c):

Ebben a programban megnézzük, hogyan működik a sizeof operátor olyan beépített adattípusoknál, mint az int, char, float, double. Nézzük meg a programot és a kimenetet.

#include
int main ()

printf ("A char mérete =% ld \ n", sizeof (char));
printf ("int mérete =% ld \ n", sizeof (int));
printf ("Az úszó mérete =% ld \ n", sizeof (úszó));
printf ("A dupla mérete =% ld \ n \ n", sizeof (dupla));
printf ("Rövid int mérete =% ld \ n", sizeof (rövid int) mérete);
printf ("A hosszú int mérete =% ld \ n", sizeof (hosszú int) mérete);
printf ("A hosszú hosszú int mérete =% ld \ n", sizeof (hosszú hosszú int mérete));
printf ("Hosszú dupla mérete =% ld \ n", sizeof (hosszú dupla));
visszatér 0;

A tömb méreteof (példa2.c)

Ebben a programban megtudjuk, hogyan kell használni a sizeof operátort különböző tömbtípusokhoz. Tömb esetén az operátor mérete visszatér (Nem. a tömb elemei * Sizeof (tömb típusa)). Például, amikor deklarálunk egy 10 elemből álló egész típusú tömböt (int SmartPhones [10];), akkor az (okostelefonok) mérete visszatér:

(Nem. elemei a SmartPhones-ban * sizeof (int)) = (10 * 4) = 40

Nézzük meg a programot és a kimenetet.

#include
int main ()

int SmartPhones [10];
char SmartPhoneNames [10];
kettős SmartPhonesPrice [10];
printf ("int mérete =% ld \ n", sizeof (int) méret);
printf ("A char mérete =% ld \ n", sizeof (char));
printf ("A dupla mérete =% ld \ n", sizeof (dupla));
/ * Tudja meg a tömb méretét * /
printf ("Az okostelefonok mérete [10] =% ld \ n", sizeof (okostelefonok) mérete);
printf ("SmartPhoneNames méret [10] =% ld \ n", sizeof (SmartPhoneNames));
printf ("A SmartPhonesPrice mérete [10] =% ld \ n", sizeof (SmartPhonesPrice));
visszatér 0;

Sizeof a felhasználó által definiált típusokhoz (példa3.c):

Ebben a példában megnézzük, hogyan lehet használni a sizeof operátort a felhasználó által definiált adattípusokhoz, például a struktúrához és az egyesítéshez. Használjuk a programot, és értsük meg a kimenetet.

Most, megnézve a programot, manuálisan kiszámíthatjuk a SmartPhoneType méretét. Amint az alább látható, a SmartPhoneType egy szerkezet, és a következő elemeket tartalmazza:

• Karaktertípus változó száma = 1 [sp_name]
• Az egész típusú változó száma = 1 [sp_version]
• Az úszó típusú változók száma = 3 [sp_length, sp_width, sp_height]

Az 1. példa alapján láttuk, hogy:

• • A karakter mérete 1 bájt
  • Egy egész szám mérete 4 bájt
  • Az úszó mérete 4 bájt

Ezért, ha összeadjuk a struktúra összes elemének méretét, akkor képesnek kell lenniünk arra, hogy megkapjuk a szerkezet méretét, azaz.e. SmartPhoneType. Ezért a szerkezet méretének = (1 + 4 + 4 + 4 + 4) bájtnak kell lennie = 17 bájtnak. A program kimenete szerint azonban a szerkezet mérete 20. A további 3 bájt (sp_name, ami egy karakter, 4 bájtot vesz el 1 bájt helyett), amelyet a struktúrához rendeltek a szerkezet kitöltése miatt.

#include
/ * Hozzon létre egy felhasználó által definiált szerkezettípust - SmartPhoneType * /
struct SmartPhoneType

char sp_name;
int sp_version;
úszó sp_hossz;
float sp_width;
lebeg sp_height;
SmartPhone;
/ * Adja meg a felhasználó által definiált uniótípust - SmartPhoneUnionType * /
Union SmartPhoneUnionType

char sp_name;
int sp_version;
úszó sp_hossz;
float sp_width;
lebeg sp_height;
SmartPhone_u;
int main ()

/ * Tudja meg a szerkezet és az egyesülés méretét * /
printf ("A struktúra mérete =% ld \ n", sizeof (SmartPhone));
printf ("Az unió mérete =% ld \ n", sizeof (SmartPhone_u));
visszatér 0;

A változók mérete (példa4.c):

Ez a példa program azt szemlélteti, hogy a sizeof operátor képes elfogadni a változót is, és visszaadja a változó méretét.

#include
int main ()

Deklarálja a char, int, float és dupla típusú változót és tömböt
char var_a, var_b [20];
int var_c, var_d [20];
úszó var_e, var_f [20];
kettős var_g, var_h [20];
/ * Tudja meg a változók és a tömb méretét.
Ez a program bemutatja, hogy a változó is képes
operátorméretként használható operátor * /
/ * char, char változó és char tömb mérete * /
printf ("A char mérete =% ld \ n", sizeof (char));
printf ("var_a mérete =% ld \ n", sizeof (var_a) mérete);
printf ("Var_b [20] =% ld \ n \ n" mérete, sizeof (var_b) mérete);
/ * int, int változó és int tömb mérete * /
printf ("int mérete =% ld \ n", sizeof (int));
printf ("A var_c mérete =% ld \ n", sizeof (var_c) mérete);
printf ("Var_d [20] =% ld \ n \ n" mérete, sizeof (var_d) mérete);
/ * az úszó, az úszó változó és az úszó tömb mérete * /
printf ("Az úszó mérete =% ld \ n", sizeof (úszó));
printf ("var_e =% ld \ n mérete, sizeof (var_e) mérete");
printf ("A var_f [20] =% ld \ n \ n" mérete, sizeof (var_f) mérete);
/ * dupla, dupla változó és dupla tömb mérete * /
printf ("A dupla mérete =% ld \ n", sizeof (dupla));
printf ("A var_g mérete =% ld \ n", sizeof (var_g) mérete);
printf ("var_h [20] =% ld \ n" mérete, sizeof (var_h) mérete);
visszatér 0;

Kifejezés mérete (példa5.c):

Ebben a példaprogramban be fogjuk mutatni, hogy a sizeof operátor elfogadhat egy kifejezést is, és visszaadhatja a kapott kifejezés méretét.

#include
int main ()

int var_a = 5, var_b = 3;
kettős var_c = 2.5, var_d = 4.5;
printf ("int mérete =% ld \ n", sizeof (int));
printf ("A dupla mérete =% ld \ n \ n", sizeof (dupla));
printf ("var_a * var_b =% ld \ n" mérete, sizeof (var_a * var_b));
printf ("var_c * var_d =% ld \ n" mérete, sizeof (var_c * var_d));
/ * Itt egy egész változót megszorzunk egy kettős változóval.
Ezért a sizeof operátor visszaadja a maximális méretet
változó i.e. kettős típusú változó.* /
printf ("var_a * var_c =% ld \ n" mérete, sizeof (var_a * var_c));
visszatér 0;

A sizeof gyakorlati használata (példa6.c):

Ez a példa program segít megérteni az operátor sizeof gyakorlati használatát. A Sizeof operátor nagyon hasznos, miközben a dinamikus memóriát kiosztja a kupacból malloc segítségével. Nézzük meg a programot és a kimenetet.

#include
#include
typedef struct

char sp_name;
int sp_version;
úszó sp_hossz;
float sp_width;
lebeg sp_height;
SmartPhoneType;
int main ()

/ * Helyezzen el memóriát a kupac memóriában öt SmartPhoneType tárolásához
változók.
* /
SmartPhoneType * SmartPhone_Ptr = (SmartPhoneType *) malloc (5 * sizeof (SmartPhoneType));
ha (SmartPhone_Ptr != NULL)

msgstr "" "Memória 5 SmartPhoneType struktúraváltozó számára lefoglalt
a Halom emlék.\ n ");

más

printf ("Hiba történt a halom memória allokálása során!");

visszatér 0;

Következtetés:

A Sizeof fontos unár operátor a C programozási nyelvben. Segít meghatározni a primitív adattípusok, a felhasználó által definiált adattípusok, kifejezések stb. Méretét. a számítógép memóriájában. A Sizeof operátor fontos szerepet játszik a dinamikus memória allokálásában C-ben malloc, calloc stb. a Halom memóriájában.