Exemple 1:
Différents fichiers d'en-tête sont importés ici : « stddef.h », « limites » et « iostream ». Les définitions des variables, types et pointeurs fréquemment utilisés peuvent être trouvées dans « stddef.h » et le fichier d'en-tête « limites » est utilisé comme constantes qui représentent les limites des types intégraux, telles que les valeurs min et max pour différents types de données. , qui sont accessibles via ce fichier d'en-tête. Ensuite, le « iostream » est ajouté car les fonctions utilisées pour entrer/sortir les données y sont définies.
Après cela, l'espace de noms « std » est ensuite ajouté ici. En dessous, la méthode « main() » est invoquée. À l’intérieur, nous plaçons le « cout » qui aide à restituer les données que nous placerons ici. Le « numeric_limits::max() » est typé car il renvoie la valeur finie la plus élevée que le type numérique « T » peut représenter. C’est significatif pour tout type borné mais cela ne peut pas être négatif.
Codage 1 :
#include
#include
#include
en utilisant espace de noms norme ;
int principal ( ) {
cout << 'La taille maximale de size_t est ' << limites_numériques :: maximum ( ) << fin ;
}
Sortir:
Nous pourrions remarquer que la taille maximale du type « T » est désormais rendue, ce qui est une valeur très grande, comme indiqué dans ce qui suit :
Exemple 2 :
Deux fichiers d'en-tête sont importés ici, dont « limits » et « iostream. Comme les fonctions nécessaires à l'entrée et à la sortie des données y sont définies, « iostream » est ajouté ici. Ensuite, le fichier d'en-tête « limites » est utilisé pour accéder aux constantes qui décrivent les limites des types intégraux telles que les valeurs min et max pour différents types de données.
Par la suite, l'espace de noms « std » est introduit ici et la fonction « main() » est appelée. En dessous, nous utilisons le « INT_MAX » à l'intérieur du « cout » pour restituer la valeur la plus élevée de la limite supérieure du type de données entier dans la programmation C++. Ensuite, dans la ligne suivante, nous utilisons le « size_t » qui donne la valeur la plus élevée.
Code 2 :
#include#include
en utilisant espace de noms norme ;
int principal ( ) {
cout << 'La valeur entière maximale : ' << INT_MAX << fin ;
cout << 'La taille que contient la fonction size_t : ' << ( taille_t ) 0 - 1 << fin ;
retour 0 ;
}
Sortir :
La taille maximale de l'entier est rendue en premier, que nous obtenons à l'aide de « INT_MAX ». Ensuite, la taille maximale stockée par « size_t » est rendue, ce que nous obtenons à l'aide de « size_t » dans ce code.
Exemple 3 :
Ici, deux fichiers d'en-tête, « climits » et « iostream », sont importés. Le « iostream » est inclus ici puisque les fonctions nécessaires à l'entrée et à la sortie des données y sont définies. Ensuite, les constantes décrivant les limites des types intégraux telles que les valeurs minimales et maximales pour différents types de données sont accessibles à l'aide du fichier d'en-tête « climits ».
Ici, la fonction « main() » est maintenant invoquée et l'espace de noms « std » est ensuite introduit. En dessous, nous utilisons le « INT_MAX » à l'intérieur du « cout » pour afficher la limite supérieure de la valeur maximale du type de données entier dans la programmation C++. En dessous, nous utilisons le « INT_MIN » qui renvoie la valeur inférieure du type de données « int ». Ensuite, nous utilisons « size_t » qui donne la valeur maximale qu'il stocke dans la ligne suivante :
Code 3 :
#include#include
en utilisant espace de noms norme ;
int principal ( ) {
cout << 'La plus grande valeur entière : ' << INT_MAX << fin ;
cout << 'Le plus petit entier : ' << INT_MIN << fin ;
cout << 'La taille que contient la fonction size_t : ' << ( taille_t ) 0 - 1 << fin ;
retour 0 ;
}
Sortir:
Tout d'abord, la taille maximale de l'entier est affichée que nous obtenons à l'aide de « INT_MAX ». Deuxièmement, la taille minimale de l'entier est affichée que nous obtenons à l'aide de « INT_MIN ». Ensuite, à l'aide de « size_t » dans ce code, la taille maximale que « size_t » stocke est rendue.
Exemple 4 :
Les fichiers d'en-tête inclus dans ce code sont « cstddef », « iostream » ainsi que « array ». Ces fichiers d'en-tête sont inclus afin que nous puissions utiliser les fonctions dont les définitions sont définies dans ces fichiers d'en-tête. Le fichier d'en-tête « array » est ajouté ici car nous devons travailler avec les « tableaux » et les fonctions dans ce code. Nous déclarons ici la variable « my_sVar » avec le « const size_t » et l'initialisons avec la valeur de « 1000 » pour restituer sa taille.
Après cela, nous déclarons également le tableau « num[] » de type de données « int » et transmettons « my_sVar » comme taille. Ensuite, nous utilisons la fonction « size_of() » dans laquelle nous plaçons la variable « num » comme paramètre et la stockons dans la variable « my_size » de type « size_t ». Ensuite, nous utilisons le « cout » et tapons « SIZE_MAX » ici pour qu'il restitue la taille maximale de la variable « my_sVar ».
Ensuite, nous montrons les éléments de type tableau en plus petits nombres. Nous le sélectionnons uniquement pour afficher 10 comme 1000, ce qui est trop nombreux pour tenir dans la sortie. En utilisant le type « size_t », nous commençons à l'index 0 pour montrer comment « size_t » peut être utilisé à la fois pour l'indexation et le comptage. Étant donné que les nombres vont diminuer, le tableau est affiché par ordre décroissant lorsque nous avons placé « –a » dans le code.
Code 4 :
#include#include
#include
