C ++ Sizeof
Syntaxe de l'opérateur sizeof () en c++
Ce qui suit décrit la syntaxe de l'opérateur sizeof ():
# sizeof (nom de data_type);Lorsqu'il est utilisé avec le premier type d'objet, la fonction SIZEOF () sortit la taille de l'objet en octets pour le type d'objet envoyé. La taille de l'élément qui est dans le type d'expression, mesuré en octets, est le deuxième type. Une fois l'expression évaluée, la taille reste la même.
Exemple 1:
Lorsque les données types comme int, flottant, char, etc. sont utilisés avec l'opérateur sizeof (), la fonction donne simplement la quantité de RAM qui est allouée à ce type de données particulier.
#inclureUtilisation de Namespace Std;
int main()
std :: cout << "Size of data type int : " <
En utilisant l'opérateur sizeof () avec la commande cout, nous évaluons la taille des types de données intégrés dans l'application susmentionnée. Comme nous pouvons le voir dans la sortie suivante, l'opération SIZEOF () donne la même réponse que nous nous attendons compte tenu de notre connaissance des tailles d'octets d'int, float, double et char.
Exemple 2:
Le programme, lorsqu'un type de classe est opératoire, utilise l'opérateur sizeof (). Voici une illustration:
#inclureUtilisation de Namespace Std;
classe MyBase_class
int x;
;
int main()
Mybase_class y;
std :: cout << "Size of Base class is : "<
Avec une seule variable entière «X» dans la classe «MyBase_Class» et la méthode principale du script susmentionné, nous évaluons la taille de la classe. Tout d'abord, nous appelons la classe donnée et créons son objet comme «Y». Ensuite, nous avons un opérateur sizeof () qui prend «Y» comme entrée. Les variables entières occupent 4 octets, donc le résultat serait de 4 octets comme imprimé ci-dessus:
Exemple 3:
Si nous augmentons le nombre de variables entières dans une classe, le code suivant est produit:
#inclureUtilisation de Namespace Std;
classe myclass_base
int i;
Int J;
;
int main()
MyClass_base J;
std :: cout << "Size of MyClass_Base is : "<
Il y a maintenant une deuxième variable entière «J» dans le code précédent. Étant donné que la variable int prend 4 octets et qu'il existe deux variables entières en tant que «I» et «J», la classe «MyClass_Base» dans ce scénario a une taille de 8 octets.
Exemple 4:
Le code peut ressembler à ce qui suit si nous incluons une variable char::
#inclureUtilisation de Namespace Std;
classe myclass
int p;
INT Q;
Char Ch;
;
int main()
MyClass Q;
std :: cout << "Size of MyClass is : "<
Deux entiers et une variable charbon sont utilisés dans le code précédent de la classe «MyClass». La taille de la classe doit être de 9 octets car il existe trois types de données (int + int + char) selon nos calculs. Mais ceci est incorrect en raison de l'idée de rembourrage de structure. Vous pouvez voir la valeur de résultat suivante:
Exemple 5:
Le cas où l'opérande est un tableau. Jetons un coup d'œil à la mise en œuvre du programme:
#inclureUtilisation de Namespace Std;
int main()
int arr_set [] = 5,15,25,35,45;
std :: cout << "Size of the 'arr_set' is : "<
Nous avons établi un tableau de type entier comme «ARR_SET» avec cinq éléments dans le programme précédent. Nous avons déterminé la taille du tableau à l'aide de l'opérateur sizeof (). Le tableau a une taille de 20 octets, car le type de données int prend 4 octets et il y a 5 entrées dans le tableau, ce qui fait un besoin d'espace mémoire total de 5 * 4 = 20 octets. Comme nous pouvons le voir dans la sortie suivante, l'opération SIZEOF () a produit le même résultat.
Exemple 6:
L'exemple prend déjà la taille du tableau. Prenons un tableau dans une perspective particulière.
#inclureUtilisation de Namespace Std;
void new_function (int array [])
std :: cout << "Size of array is : " <
int main()
int array [] = 51,52,53,54,55;
new_function (array);
retour 0;
Nous avons essayé d'utiliser la fonction «new_function» dans l'application susmentionnée pour imprimer la taille du tableau. Nous avons formé un tableau de type entier dans ce cas, et nous envoyons le paramètre "Array" au new_function (). La taille du pointeur entier ou int * est renvoyée par le new_function (). Dans les systèmes d'exploitation 64 bits, la taille de l'int * est de 8 octets. La sortie génère la taille du tableau comme suit:
Exemple 7:
Maintenant, c'est l'exemple où l'argument est le type de pointeur à l'intérieur de l'opérateur de taille ().
#inclureUtilisation de Namespace Std;
int main()
int * ptr1 = new int (31);
std :: cout << "ptr1 size:" <
std :: cout <<"ptr2 size :" <
std :: cout <<"ptr3 size :" <
Nous avons calculé la taille des pointeurs dans le script mentionné dans le précédemment. Pour les types de données «int», «double» et «char», les tailles de pointeur restent constantes. La taille du pointeur est de 4 octets si l'ordinateur avait un système d'exploitation 32 bits. La taille du pointeur est de 8 octets si l'ordinateur exécute un système d'exploitation 64 bits. Le résultat est de 8 octets alors que nous exécutons ce script sur une plate-forme 64 bits. Maintenant, si nous donnons au pointeur le symbole «*», la sortie change en fonction du type de données. Par exemple, si * ptr1 est un type entier, l'opérateur sizeof () donne 4 octets car un type de données int prend 4 octets. Ce qui suit est la taille résultante des pointeurs correspondant à chaque type de données spécifié:
Exemple 8:
L'exemple où nous avons une expression en tant qu'opérande de taille ().
#inclureUtilisation de Namespace Std;
int main()
int Integer_1;
Double Integer_2;
couter << "size of int and double: " <
Nous avons deux variables, Integer_1 et Integer_2, des types int et doubles, respectivement. Ils sont déclarés dans le programme. Comme nous le savons, les entiers ont une taille de 4 octets tandis que les doubles sont de 8 octets. Nous les avons ajoutés tous les deux dans l'opérateur de taille (). La variable, double avec une taille de 8 octets, est le résultat.
Conclusion
Une explication sizeof () de C ++ se termine ici. Nous avons examiné les détails sur le fonctionnement de l'opérateur C ++ sizeof (), ainsi que des exemples pertinents. Tout type de données, expression, tableau, etc. peut avoir sa taille déterminée en utilisant l'opérateur de taille (). Le type de données ou une expression doit être fourni dans le cadre de l'argument. Et la fonction renvoie la taille de ce type de données en octets en conséquence.