Phenquestions
Comprendre la taille de :
Avant de plonger dans la discussion sur la taille 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 un opérateur unaire. L'opérateur sizeof est l'un des opérateurs unaires qui existent dans le langage de programmation C et apparemment, il ne fonctionne que sur un opérande. L'opérateur sizeof renvoie la taille de l'opérande. Cela signifie que, à partir de la valeur de retour de l'opérateur Sizeof, nous pouvons clairement dire combien d'octets alloués pour contenir l'opérande particulier dans la mémoire de l'ordinateur.
La mémoire d'un ordinateur est un ensemble d'unités de mémoire (i.e. octet). Lorsque sizeof (int) renvoie quatre dans un système informatique particulier, nous pouvons dire qu'une variable entière prend 4 octets pour conserver sa valeur dans la mémoire de ce système informatique spécifique. Veuillez également noter que la valeur de retour de l'opérateur sizeof dépend également des machines que vous utilisez (système 32 bits ou système 64 bits).
Syntaxe:
Taillede(type)Taillede(expression)
Le type de retour de sizeof est size_t.
Exemples:
Maintenant que nous comprenons l'opérateur sizeof et connaissons la syntaxe, regardons quelques exemples, qui nous aideront à 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 (exemple 3.c)
- Sizeof pour les variables (exemple4.c)
- Sizeof pour l'expression (exemple5.c)
- Utilisation pratique de sizeof (exemple 6.c)
Sizeof pour les types intégrés (exemple1.c) :
Dans ce programme, nous verrons comment fonctionne l'opérateur sizeof pour les types de données intégrés tels que int, char, float, double. Regardons le programme et la sortie.
#inclureint main()
printf("Taille du char = %ld \n", sizeof(char));
printf("Taille de int = %ld \n", sizeof(int));
printf("Taille de float = %ld \n", sizeof(float));
printf("Taille du double = %ld \n\n", sizeof(double));
printf("Taille de l'entier court = %ld \n", sizeof(entier court));
printf("Taille de l'entier long = %ld \n", sizeof(entier long));
printf("Taille du long long int = %ld \n", sizeof(long long int));
printf("Taille du long double = %ld \n", sizeof(long double));
renvoie 0 ;
Sizeof pour le tableau (exemple2.c)
Dans ce programme, nous verrons comment utiliser l'opérateur sizeof pour différents types de tableau. Dans le cas d'un tableau, l'opérateur sizeof renverra (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] ;), le sizeof(Smartphones) retournera :
(Non. d'éléments dans les SmartPhones * sizeof(int)) = (10 * 4) = 40Regardons le programme et la sortie.
#inclureint main()
int SmartPhones[10] ;
char SmartPhoneNames[10];
double SmartPhonesPrice[10] ;
printf("Taille de int = %ld \n", sizeof(int));
printf("Taille du char = %ld \n", sizeof(char));
printf("Taille du double = %ld \n", sizeof(double));
/* Connaître la taille du tableau*/
printf("Taille des SmartPhones[10] = %ld \n", sizeof(SmartPhones));
printf("Taille des SmartPhoneNames[10] = %ld \n", sizeof(SmartPhoneNames));
printf("Taille de SmartPhonesPrice[10] = %ld \n", sizeof(SmartPhonesPrice));
renvoie 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 structure et union. Utilisons le programme et comprenons le résultat.
Maintenant, en regardant le programme, et nous pouvons calculer manuellement la taille de SmartPhoneType. Comme vous pouvez le voir ci-dessous, SmartPhoneType est une structure et contient les éléments suivants :
- Nombre de variable de type caractère = 1 [sp_name]
- Nombre de variable de type entier = 1 [sp_version]
- Nombre de variables de type flottant = 3 [sp_length, sp_width, sp_height]
De 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 flottant 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, i.e. Type de téléphone intelligent. 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 caractère, prend 4 octets au lieu de 1 octet) alloués à la structure en raison du remplissage de la structure.
#inclure/* Créer un type de structure défini par l'utilisateur - SmartPhoneType*/
struct SmartPhoneType
char sp_name;
int version_sp;
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*/
UnionSmartPhoneUnionType
char sp_name;
int version_sp;
float sp_length;
float sp_width;
float sp_height;
SmartPhone_u;
int main()
/* Connaître la taille de la structure et du syndicat*/
printf("Taille de la structure = %ld \n", sizeof(SmartPhone));
printf("Taille de l'union = %ld \n", sizeof(SmartPhone_u));
renvoie 0 ;
Sizeof pour les variables (exemple4.c) :
Cet exemple de programme montre que l'opérateur sizeof est capable d'accepter la variable également et de renvoyer la taille de la variable.
#inclureint main()
/* Déclare la variable et le tableau char, int, float et double type */
char var_a, var_b[20] ;
int var_c, var_d[20] ;
float var_e, var_f[20] ;
double var_g, var_h[20] ;
/* Connaître la taille des variables et du tableau.
Ce programme démontre que la variable peut également
être utilisé comme opérande sizeof opérateur*/
/* taille du char, de la variable char et du tableau char*/
printf("Taille du 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 des int, variable int et tableau int*/
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 du flottant, de la variable flottante et du tableau flottant*/
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 du double, double variable et double tableau*/
printf("Taille du 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));
renvoie 0 ;
Taille de l'expression (exemple 5.c) :
Dans cet exemple de programme, nous allons démontrer que l'opérateur sizeof peut également accepter une expression et renvoyer la taille de l'expression résultante.
#inclureint 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 du 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 par une variable double.
Par conséquent, l'opérateur sizeof renverra la taille de la taille maximale
variable je.e. variable de type double.*/
printf("Taille de var_a * var_c = %ld \n", sizeof(var_a * var_c));
renvoie 0 ;
Utilisation pratique de sizeof (exemple 6.c) :
Cet exemple de programme vous aidera à comprendre un cas d'utilisation pratique de l'opérateur sizeof. L'opérateur Sizeof est très utile lors de l'allocation de la mémoire dynamique du tas à l'aide de malloc. Regardons le programme et la sortie.
#inclure#inclure
struct typedef
char sp_name;
int version_sp;
float sp_length;
float sp_width;
float sp_height;
Type de téléphone intelligent ;
int main()
/* Allouer de la mémoire dans la mémoire Heap pour contenir cinq SmartPhoneType
variables.
*/
SmartPhoneType * SmartPhone_Ptr = (SmartPhoneType *)malloc(5 * sizeof(SmartPhoneType));
if(SmartPhone_Ptr != NULL)
printf("Mémoire allouée pour 5 variables de structure SmartPhoneType dans
la mémoire du tas.\n");
autre
printf("Une erreur s'est produite lors de l'allocation de mémoire du tas!");
renvoie 0 ;
Conclusion:
Le Sizeof 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 de l'ordinateur. L'opérateur Sizeof joue un rôle important dans l'allocation de mémoire dynamique en C à l'aide de malloc, calloc, etc. dans la mémoire du tas.
