Taille de l'opérateur en langue C

Dans cet article, nous allons en apprendre davantage sur la taille de l'opérateur en C. Il s'agit d'un opérateur unaire largement utilisé dans le développement de logiciels intégrés, qui nous aide à découvrir la taille de l'opérande. Par conséquent, la valeur de retour de la taille de l'opérateur nous aide à comprendre le nombre d'octets alloués dans la mémoire de l'ordinateur pour maintenir la variable ou le type de données particulier.

Comprendre la taille:

Avant de plonger dans la taille de la discussion de l'opérateur, comprenons d'abord la signification de l'opérateur. Un opérateur est représenté par un jeton ou un symbole qui est utilisé pour effectuer une opération telle que l'addition, la soustraction, la multiplication, la division, etc. sur des valeurs ou des variables (opérandes). Par exemple, «*» est le symbole qui est utilisé pour représenter l'opération de multiplication, et il fonctionne sur deux opérandes (résultat = a * b;). Ceci est un exemple d'opérateur binaire.

Cependant, si un opérateur travaille sur un seul opérande, nous appelons un tel opérateur comme un opérateur unaire. La taille de l'opérateur est l'un des opérateurs unaires qui existent dans le langage de programmation C et apparemment, il ne fonctionne que sur un seul opérande. La taille de l'opérateur renvoie la taille de l'opérande. Cela signifie que, à partir de la valeur de retour de la taille de l'opérateur, nous pouvons clairement dire combien d'octets alloués pour maintenir l'opérande particulier dans la mémoire de l'ordinateur.

La mémoire d'un ordinateur est une collection d'unités de mémoire (i.e. octet). Lorsque la taille de (int) renvoie quatre dans un système informatique particulier, nous pouvons dire qu'une variable entière prend 4 octets pour maintenir sa valeur dans la mémoire de ce système informatique spécifique. Veuillez également noter que la valeur de retour de la taille de l'opérateur dépend également des machines que vous utilisez (système 32 bits ou système 64 bits).

Syntaxe:

Taille de (type)
Taille de (expression)

Le type de retour de taille est size_t.

Exemples:

Maintenant, puisque nous comprenons la taille de l'opérateur et connaissons la syntaxe, regardons quelques exemples, ce qui nous aidera à mieux comprendre le concept.

• Sizeof pour les types intégrés (exemple1.c)
• Sizeof pour le tableau (Exemple2.c)
• Sizeof pour les types définis par l'utilisateur (Exemple3.c)
• Sizeof pour les variables (Exemple4.c)
• Taille pour l'expression (Exemple5.c)
• Utilisation pratique de la taille (Exemple6.c)

Sizeof pour les types intégrés (exemple1.c):

Dans ce programme, nous verrons comment fonctionne la taille de l'opérateur pour les types de données intégrés tels que int, char, float, double. Regardons le programme et la sortie.

#inclure
int main()

printf ("taille de char =% ld \ n", sizeof (char));
printf ("taille de int =% ld \ n", sizeof (int));
printf ("taille de float =% ld \ n", sizeof (float));
printf ("taille de double =% ld \ n \ n", sizeof (double));
printf ("taille de court int =% ld \ n", sizeof (court int));
printf ("taille de long int =% ld \ n", sizeof (long int));
printf ("taille de long long int =% ld \ n", sizeof (long long int));
printf ("Taille de long double =% ld \ n", sizeof (long double));
retour 0;

Sizeof pour le tableau (Exemple2.c)

Dans ce programme, nous verrons comment utiliser la taille de l'opérateur pour différents types de tableau. En cas de tableau, la taille de l'opérateur reviendra (non. d'éléments dans le tableau * sizeof (type de tableau))). Par exemple, lorsque nous déclarons un tableau de type entier de 10 éléments (INT Smartphones [10];), la taille de (smartphones) reviendra:

(Non. d'éléments dans les smartphones * sizeof (int)) = (10 * 4) = 40

Regardons le programme et la sortie.

#inclure
int main()

INT Smartphones [10];
char smartphonenames [10];
Double SmartphonesPrice [10];
printf ("taille de int =% ld \ n", sizeof (int));
printf ("taille de char =% ld \ n", sizeof (char));
printf ("taille de double =% ld \ n", sizeof (double));
/ * Découvrez la taille du tableau * /
printf ("taille des smartphones [10] =% ld \ n", sizeof (smartphones));
printf ("taille de smartphonenames [10] =% ld \ n", sizeof (smartphonenames));
printf ("taille de smartphonesPrice [10] =% ld \ n", sizeof (smartphonesprice));
retour 0;

Sizeof pour les types définis par l'utilisateur (Exemple3.c):

Dans cet exemple, nous verrons comment utiliser l'opérateur SizeOf pour les types de données définis par l'utilisateur tels que la structure et l'union. Utilisons le programme et comprenons la sortie.

Maintenant, en regardant le programme, et nous pouvons calculer manuellement la taille du smartphonetype. Comme vous pouvez le voir ci-dessous, Smartphonetype est une structure et il contient les éléments suivants:

• Nombre de variables de type de caractères = 1 [SP_NAME]
• Nombre de variables de type entier = 1 [SP_VERSION]
• Nombre de variables de type float = 3 [sp_length, sp_width, sp_height]

D'après l'exemple-1, nous avons vu que:

• • La taille du caractère est de 1 octet
  • La taille d'un entier est de 4 octets
  • La taille d'un flotteur est de 4 octets

Par conséquent, si nous additionnons la taille de tous les éléments de la structure, nous devrions pouvoir obtenir la taille de la structure, je.e. Smartphonetype. Par conséquent, la taille de la structure doit être = (1 + 4 + 4 + 4 + 4) octets = 17 octets. Cependant, la sortie du programme indique que la taille de la structure est de 20. Les 3 octets supplémentaires (SP_NAME, qui est un personnage, prend 4 octets au lieu de 1 octet) alloués à la structure en raison du rembourrage de la structure.

#inclure
/ * Créer un type de structure défini par l'utilisateur - SmartPhonetype * /
struct smartphonetype

char sp_name;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
Téléphone intelligent;
/ * Définir un type d'union défini par l'utilisateur - SmartPhoneUnionType * /
Union smartphoneUnionType

char sp_name;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
Smartphone_u;
int main()

/ * Découvrez la taille de la structure et de l'union * /
printf ("taille de struct =% ld \ n", sizeof (smartphone));
printf ("Taille de Union =% ld \ n", sizeof (smartphone_u));
retour 0;

Sizeof pour les variables (Exemple4.c):

Cet exemple de programme illustre que la taille de l'opérateur est capable d'accepter également la variable et de renvoyer la taille de la variable.

#inclure
int main()

/ * Déclarer la variable char, int, float et double type et tableau * /
char var_a, var_b [20];
int var_c, var_d [20];
float var_e, var_f [20];
double var_g, var_h [20];
/ * Découvrez la taille des variables et du tableau.
Ce programme démontre que la variable peut également
être utilisé comme un opérateur de la taille de l'opérateur * /
/ * taille de char, variable de char et array de char * /
printf ("taille de char =% ld \ n", sizeof (char));
printf ("taille de var_a =% ld \ n", sizeof (var_a));
printf ("taille de var_b [20] =% ld \ n \ n", sizeof (var_b));
/ * taille de int, variable int et int array * /
printf ("taille de int =% ld \ n", sizeof (int));
printf ("taille de var_c =% ld \ n", sizeof (var_c));
printf ("taille de var_d [20] =% ld \ n \ n", sizeof (var_d));
/ * taille de flotteur, variable de flotteur et tableau de flotteur * /
printf ("taille de float =% ld \ n", sizeof (float));
printf ("taille de var_e =% ld \ n", sizeof (var_e));
printf ("taille de var_f [20] =% ld \ n \ n", sizeof (var_f));
/ * taille de double, double variable et double tableau * /
printf ("taille de double =% ld \ n", sizeof (double));
printf ("taille de var_g =% ld \ n", sizeof (var_g));
printf ("taille de var_h [20] =% ld \ n", sizeof (var_h));
retour 0;

Taille pour l'expression (Exemple5.c):

Dans cet exemple de programme, nous démontrerons que la taille de l'opérateur peut également accepter une expression et renvoyer la taille de l'expression résultante.

#inclure
int main()

int var_a = 5, var_b = 3;
double var_c = 2.5, var_d = 4.5;
printf ("taille de int =% ld \ n", sizeof (int));
printf ("taille de double =% ld \ n \ n", sizeof (double));
printf ("taille de var_a * var_b =% ld \ n", sizeof (var_a * var_b));
printf ("taille de var_c * var_d =% ld \ n", sizeof (var_c * var_d));
/ * Ici, nous multiplions une variable entière avec une double variable.
Par conséquent, l'opérateur de taille
variable i.e. Variable à double type.* /
printf ("taille de var_a * var_c =% ld \ n", sizeof (var_a * var_c));
retour 0;

Utilisation pratique de la taille (Exemple6.c):

Cet exemple de programme vous aidera à comprendre un cas d'utilisation pratique de la taille de l'opérateur. La taille de l'opérateur est très utile tout en allouant la mémoire dynamique à partir de tas à l'aide de Malloc. Regardons le programme et la sortie.

#inclure
#inclure
typedef struct

char sp_name;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
Smartphonetype;
int main()

/ * Allouer de la mémoire dans la mémoire du tas pour maintenir cinq smartphonetype
variables.
* /
Smartphonetype * smartphone_ptr = (smartphonetyty *) malloc (5 * sizeof (smartphonetype));
if (smartphone_ptr != Null)

printf ("Mémoire allouée pour 5 variables de structure de smartphonetype dans
La mémoire du tas.\ n ");

autre

printf ("Erreur s'est produite pendant l'allocation de mémoire du tas!");

retour 0;

Conclusion:

La taille est un opérateur unaire important dans le langage de programmation C. Il nous aide à déterminer la taille des types de données primitifs, des types de données définis par l'utilisateur, des expressions, etc. dans la mémoire informatique. La taille de l'opérateur joue un rôle important dans l'allocation de la mémoire dynamique en C en utilisant malloc, calloc, etc. dans la mémoire du tas.