La plupart du temps, dans la programmation compétitive, il est nécessaire d'attribuer à la variable, la valeur maximale ou minimale que le type de données peut contenir, mais se souvenir d'un nombre aussi grand et précis s'avère être une tâche difficile. Par conséquent, C/C++ dispose de certaines macros pour représenter ces nombres, de sorte que ceux-ci puissent être directement affectés à la variable sans avoir à saisir le nombre entier.
C/C++ fournit deux de ces macros, à savoir INT_MAX et INT_MIN, qui représentent les limites entières. Selon le compilateur et la norme C++, vous devrez peut-être inclure le fichier d'en-tête ou dans votre code source C ou C++ respectivement. Il est donc conseillé d'inclure ce fichier d'en-tête pour utiliser les macros INT_MAX et INT_MIN. Pour en savoir plus sur ce fichier d'en-tête, référez-vous à cet article .
INT_MAX en C/C++
INT_MAX est une macro qui spécifie qu'une variable entière ne peut stocker aucune valeur au-delà de cette limite. Il représente le valeur maximale de la limite supérieure du type de données entier en C/C++.
La valeur de INT_MAX est :
java int sous forme de chaîne
- INT_MAX = 2147483647 (pour les entiers 32 bits)
- INT_MAX = 9 223 372 036 854 775 807 (pour les entiers 64 bits)
INT_MIN en C/C++
INT_MIN est une macro qui spécifie qu'une variable entière ne peut stocker aucune valeur inférieure à cette limite. Il représente le valeur minimale ou limite inférieure du type de données entier.
La valeur de INT_MIN est :
- INT_MIN = – 2147483648 (pour les entiers 32 bits)
- INT_MIN = – 9 223 372 036 854 775 808 (pour les entiers 64 bits)
Note: Les valeurs de INT_MAX et INT_MIN peuvent varier d'un compilateur à l'autre. Voici les valeurs typiques d'un compilateur où les entiers sont stockés sur 32 bits.
Exemple de INT_MIN et INT_MAX
C++ // C++ program to print values of INT_MAX // and INT_MIN #include #include using namespace std; int main() { cout << INT_MAX << endl; cout << INT_MIN; return 0; }> C // C program to print values of INT_MAX // and INT_MIN // we have to include limits.h for results in C #include #include int main() { printf('%d
', INT_MAX); printf('%d', INT_MIN); }> Sortir
2147483647 -2147483648>
Applications de INT_MAX et INT_MIN
Voici les principales applications de INT_MAX et INT_MIN
1. Vérifiez le débordement d'entier
Nous pouvons utiliser les macros INT_MIN et INT_MAX pour vérifier le dépassement d'entier signé. L'exemple ci-dessous montre comment procéder.
Exemple
C++ // C++ code to check for Integer overflow while // adding 2 numbers #include #include using namespace std; // Function to return integer sum after checking overflow int check_overflow(int num1, int num2) { // Checking if addition will cause overflow if (num1>INT_MAX - num2) renvoie -1 ; // Aucun débordement ne s'est produit sinon return num1 + num2; } // Code du pilote int main() { // La somme de ces nombres sera égale à INT_MAX // Si l'un d'entre eux est incrémenté de 1, un débordement // se produira int num1 = 2147483627; int num2 = 20 ; // Le résultat est -1 si un débordement s'est produit // Stocke la somme, sinon int result = check_overflow(num1, num2); // Un débordement s'est produit si (result == -1) cout<< 'Integer overflow occurred'; // No overflow else cout << result; return 0; }> C // C code to check for Integer overflow while // adding 2 numbers #include #include // Function to check integer overflow int check_overflow(int num1, int num2) { // Checking if addition will cause overflow if (num1>INT_MAX - num2) renvoie -1 ; // Aucun débordement ne s'est produit sinon return num1 + num2; } int main(void) { // La somme de ces nombres sera équivalente à // INT_MAX Si l'un d'entre eux est incrémenté de 1, un débordement // se produira int num1 = 2147483627; int num2 = 20 ; // Le résultat est -1 si un débordement s'est produit // Stocke la somme, sinon int result = check_overflow(num1, num2); // Un débordement s'est produit si (result == -1) printf('Un débordement d'entier s'est produit'); // Pas de débordement sinon printf('%d', result); renvoie 0 ; } // Ce code est contribué par sarajadhav12052009> Sortir
2147483647>
De même, nous pouvons vérifier le débordement en soustrayant 2 nombres en utilisant INT_MIN.
code de codage de Huffman
2. Calcul de MIN dans un tableau avec de grands éléments
Nous attribuons généralement une valeur élevée à MIN pour calculer la valeur minimale dans un tableau. Mais si un tableau comporte de grands éléments, nous devons attribuer la valeur la plus élevée possible au tableau.
Ci-dessous la mise en œuvre :
Exemple
C++ // C++ code to compute MIN element #include #include using namespace std; // Function to compute minimum element in array int compute_min(int arr[], int n) { // Assigning highest value int MIN = INT_MAX; // Traversing and updating MIN for (int i = 0; i < n; i++) MIN = std::min(MIN, arr[i]); // Printing MIN element cout << MIN; } // Driver code int main() { // array with MIN to compute int arr[] = { 2019403813, 2147389580, 2145837140, 2108938594, 2112076334 }; // size of array int n = sizeof(arr) / sizeof(arr[0]); // Function call to compute MIN compute_min(arr, n); }> Sortir
2019403813>
De même, MAX peut être trouvé dans un tableau de grands nombres en utilisant INT_MIN.
FAQ sur INT_MIN et INT_MAX
1. Pourquoi abs(INT_MIN) ne donne pas le résultat attendu ?
Avez-vous déjà rencontré un problème lorsque vous auriez pu utiliser la fonction abs() ? Très probablement NON si vous n’avez résolu aucun problème nécessitant une fonction absolue. Mais si vous avez résolu des problèmes sur techcodeview.com ou Leetcode, vous savez qu'il y a toujours un cas de test où vous échouez et ce cas de test est celui où vous avez la valeur INT_MIN.
Voyons ce qui se passe si nous utilisons la fonction absolue, elle renvoie la valeur mod, ce qui signifie qu'elle renvoie la valeur suivante :
bonjour tout le monde java
Valeurs de module
Maintenant, une autre chose que nous savons est que la plage des nombres entiers va de -2 147 483 648 à 2 147 483 647 ou nous pouvons dire que c'est de -2 31 à 2 31 - 1 donc comme nous pouvons voir qu'il y a toujours un de plus du côté négatif que du côté positif
Voyons maintenant ce qui se passe lorsque nous essayons de prendre des valeurs absolues du résultat :
C++ // C++ program to demonstrate the common error faced when // getting absolute value of the INT_MIN #include #include using namespace std; int main() { cout << 'Value Of INT_MIN is : ' << INT_MIN << endl; cout << 'Value Of abs(INT_MIN) is : ' << abs(INT_MIN) << endl; return 0; }> C // C program to demonstrate the common error faced when // getting absolute value of the INT_MIN #include #include #include int main() { printf('Value of INT_MIN is: %d
', INT_MIN); printf('Value of abs(INT_MIN) is: %d', abs(INT_MIN)); return 0; }> Sortir
Value of INT_MIN is: -2147483648 Value of abs(INT_MIN) is: -2147483648>
Nous pouvons maintenant observer que abs(INT_MIN) est INT_MIN lui-même, ce qui provoque de nombreuses erreurs lorsque nous donnons des évaluations en ligne ou résolvons un problème.
java mathématiques
Raison
Maintenant, si nous arrivons à la partie raison, nous pouvons voir que nous avons actuellement affaire à la partie Integer et abs(integer) renvoie lui-même une valeur entière, donc passer à côté de la représentation INT_MIN peut être représenté comme
INT_MIN = -2147483648 = 10000000000000000000000000000000>
Ici, le 1er bit représente le bit de signe qui est défini sur un, ce qui signifie qu'il s'agit d'un nombre négatif et la partie suivante est une représentation binaire de 31 bits pour 2147483648.
Maintenant, si nous essayons de prendre la valeur absolue de INT_MIN, cela essaiera de nous donner +2147483648 et cette valeur ne peut pas être représentée sous la forme entière car la valeur maximale pouvant être représentée est +2147483647 car du côté positif, nous devons représentent 231 entiers mais 0 est également inclus, donc la plage de 1 à 2147483648 passe de 0 à 2147483647 et pour cette raison, abs(INT_MIN) ne peut pas être représenté dans cette plage et la réponse renvoyée est la même que INT_MIN.
Solution
Eh bien, il peut y avoir de nombreuses solutions au problème, mais certaines des meilleures solutions sont :
- Utilisez toujours un cas particulier pour vérifier if(x == INT_MIN) si vous utilisez abs(x) et gérez ce cas en conséquence.
- Essayez d'utiliser Long au lieu de INTEGER mais rappelez-vous que LONG_MIN donnera également le même résultat, alors soyez prudent.