La majoria de vegades, en la programació competitiva, cal assignar la variable, el valor màxim o mínim que pot contenir el tipus de dades, però recordar un nombre tan gran i precís resulta ser una feina difícil. Per tant, C/C++ té certes macros per representar aquests nombres, de manera que aquests es poden assignar directament a la variable sense haver d'escriure el nombre sencer.
C/C++ proporciona dues macros d'aquest tipus, INT_MAX i INT_MIN, que representen els límits enters. Depenent del compilador i de l'estàndard C++, és possible que se us demani que inclogueu el fitxer de capçalera o al vostre codi font C o C++ respectivament. Per tant, és recomanable incloure aquest fitxer de capçalera per utilitzar les macros INT_MAX i INT_MIN. Per a més informació sobre aquest fitxer de capçalera, consulteu aquest article .
INT_MAX en C/C++
INT_MAX és una macro que especifica que una variable entera no pot emmagatzemar cap valor més enllà d'aquest límit. Representa el valor màxim del límit superior del tipus de dades enter en C/C++.
El valor de INT_MAX és:
codi de mostra c#
- INT_MAX = 2147483647 (per a nombres enters de 32 bits)
- INT_MAX = 9,223,372,036,854,775,807 (per a nombres enters de 64 bits)
INT_MIN en C/C++
INT_MIN és una macro que especifica que una variable entera no pot emmagatzemar cap valor per sota d'aquest límit. Representa el valor mínim o el límit inferior del tipus de dades enter.
El valor de INT_MIN és:
- INT_MIN = – 2147483648 (per a nombres enters de 32 bits)
- INT_MIN = – 9,223,372,036,854,775,808 (per a nombres enters de 64 bits)
Nota: Els valors d'INT_MAX i INT_MIN poden variar d'un compilador a un altre. A continuació es mostren els valors típics d'un compilador on els nombres enters s'emmagatzemen amb 32 bits.
any mes
Exemple de INT_MIN i 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); }> Sortida
2147483647 -2147483648>
Aplicacions de INT_MAX i INT_MIN
A continuació es mostren les principals aplicacions d'INT_MAX i INT_MIN
1. Comproveu si hi ha un desbordament enter
Podem utilitzar les macros INT_MIN i INT_MAX per comprovar el desbordament d'enter signat. L'exemple següent mostra com fer-ho.
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) retorna -1; // No s'ha produït cap desbordament, sinó retorna num1 + num2; } // Codi del controlador int main() { // La suma d'aquests nombres serà igual a INT_MAX // Si algun d'ells s'incrementa en 1, el desbordament // es produirà int num1 = 2147483627; int num2 = 20; // El resultat és -1 si s'ha produït un desbordament // Emmagatzema la suma, en cas contrari int resultat = check_overflow(num1, num2); // S'ha produït un desbordament si (resultat == -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) retorna -1; // No s'ha produït cap desbordament, sinó retorna num1 + num2; } int main(void) { // La suma d'aquests nombres serà equivalent a // INT_MAX Si algun d'ells s'incrementa en 1, el desbordament // es produirà int num1 = 2147483627; int num2 = 20; // El resultat és -1 si s'ha produït un desbordament // Emmagatzema la suma, en cas contrari int resultat = check_overflow(num1, num2); // S'ha produït un desbordament si (resultat == -1) printf('S'ha produït un desbordament d'enters'); // Sense desbordament sinó printf('%d', resultat); retorn 0; } // Aquest codi és aportat per sarajadhav12052009>>
Sortida 2147483647>
De la mateixa manera, podem comprovar si hi ha un desbordament mentre restem 2 nombres amb INT_MIN.
2. Calcular MIN en una matriu amb elements grans
Normalment assignem un valor alt a MIN per calcular el valor mínim en una matriu. Però si una matriu té elements grans, hem d'assignar el valor més alt possible a la matriu.
A continuació es mostra la implementació:
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); }> Sortida
Preguntes freqüents sobre INT_MIN i INT_MAX
1. Per què abs(INT_MIN) no dóna el resultat esperat?
Alguna vegada t'has enfrontat a un problema quan potser has utilitzat la funció abs()? Probablement NO si no heu resolt cap problema que requereixi una funció absoluta. Però si heu resolt problemes a techcodeview.com o Leetcode, sabeu que sempre hi ha un cas de prova en què falla i aquest cas de prova és quan teniu el valor INT_MIN.
Vegem què passa si utilitzem la funció absoluta retorna el valor mod, que vol dir que retorna el valor següent:
com obrir un fitxer en java
Valors del mòdul
Ara una altra cosa que sabem és que el rang de nombres enters és de -2.147.483.648 a 2.147.483.647 o podem dir que és de -2 31 a 2 31 – 1 així com podem veure que n'hi ha sempre un més al costat negatiu que al positiu
nat vs llit
Ara vegem què passa quan intentem prendre valors absoluts del resultat:
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; }> Sortida
Value of INT_MIN is: -2147483648 Value of abs(INT_MIN) is: -2147483648>
Ara podem observar que abs(INT_MIN) és el mateix INT_MIN, i això fa que es produeixin molts errors quan fem avaluacions en línia o solucionem qualsevol problema.
Raó
Ara, si arribem a la part de la raó, podem veure que actualment estem tractant amb la part Sencer i abs(enteger) retorna un valor enter, de manera que moure's al costat de la representació INT_MIN es pot representar com
INT_MIN = -2147483648 = 10000000000000000000000000000000>
Aquí el primer bit representa el bit de signe que s'estableix en un, el que significa que és un nombre negatiu i la part següent és una representació binària de 31 bits per a 2147483648.
Ara, si intentem prendre el valor absolut de INT_MIN, intentarà donar-nos +2147483648 i aquest valor no es pot representar en forma enter, ja que el valor màxim que es pot representar és +2147483647 ja que al costat positiu hem de representen 231 nombres enters però també s'inclou 0, de manera que l'interval d'1 a 2147483648 canvia a 0 a 2147483647 i per aquest motiu l'abs(INT_MIN) no es pot representar en aquest interval i la resposta retornada és la mateixa que INT_MIN.
Solució
Bé, pot haver-hi moltes solucions al problema, però algunes de les millors solucions són:
- Utilitzeu sempre un cas de vora especial per comprovar si (x == INT_MIN) si feu servir abs(x) i manegeu aquest cas en conseqüència.
- Proveu d'utilitzar Long en comptes de INTEGER, però recordeu que LONG_MIN també donarà el mateix resultat, així que aneu amb compte.