La maggior parte delle volte, nella programmazione competitiva, è necessario assegnare alla variabile il valore massimo o minimo che il tipo di dato può contenere, ma ricordare un numero così grande e preciso risulta essere un lavoro difficile. Pertanto, C/C++ dispone di determinate macro per rappresentare questi numeri, in modo che questi possano essere assegnati direttamente alla variabile senza effettivamente digitare l'intero numero.
C/C++ fornisce due macro di questo tipo, ovvero INT_MAX e INT_MIN che rappresentano i limiti dei numeri interi. A seconda del compilatore e dello standard C++, potrebbe essere necessario includere il file di intestazione O rispettivamente nel codice sorgente C o C++. Quindi è consigliabile includere questo file di intestazione per utilizzare le macro INT_MAX e INT_MIN. Per ulteriori letture su questo file di intestazione, fare riferimento a questo articolo .
INT_MAX in C/C++
INT_MAX è una macro che specifica che una variabile intera non può memorizzare alcun valore oltre questo limite. Rappresenta il valore massimo del limite superiore del tipo di dati intero in C/C++.
Il valore di INT_MAX è:
versione java linux
- INT_MAX = 2147483647 (per numeri interi a 32 bit)
- INT_MAX = 9.223.372.036.854.775.807 (per numeri interi a 64 bit)
INT_MIN in C/C++
INT_MIN è una macro che specifica che una variabile intera non può memorizzare alcun valore al di sotto di questo limite. Rappresenta il valore minimo o il limite inferiore del tipo di dati intero.
Il valore di INT_MIN è:
- INT_MIN = – 2147483648 (per numeri interi a 32 bit)
- INT_MIN = – 9.223.372.036.854.775.808 (per numeri interi a 64 bit)
Nota: I valori di INT_MAX e INT_MIN possono variare da compilatore a compilatore. Di seguito sono riportati i valori tipici in un compilatore in cui gli interi vengono memorizzati utilizzando 32 bit.
Esempio di INT_MIN e 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); }> Produzione
2147483647 -2147483648>
Applicazioni di INT_MAX e INT_MIN
Di seguito sono riportate le principali applicazioni di INT_MAX e INT_MIN
1. Controllare l'overflow di numeri interi
Possiamo utilizzare le macro INT_MIN e INT_MAX per verificare l'overflow dell'intero con segno. L'esempio seguente mostra come farlo.
Esempio
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) ritorno -1; // Non si è verificato alcun overflow altrimenti return num1 + num2; } // Codice driver int main() { // La somma di questi numeri sarà uguale a INT_MAX // Se uno qualsiasi di essi viene incrementato di 1, si verificherà un overflow // int num1 = 2147483627; numero intero2 = 20; // Il risultato è -1 se si è verificato un overflow // Memorizza la somma, altrimenti int result = check_overflow(num1, num2); // Si è verificato un overflow se (risultato == -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) ritorno -1; // Non si è verificato alcun overflow altrimenti return num1 + num2; } int main(void) { // La somma di questi numeri sarà equivalente a // INT_MAX Se uno qualsiasi di essi viene incrementato di 1, si verificherà un overflow // int num1 = 2147483627; numero intero2 = 20; // Il risultato è -1 se si è verificato un overflow // Memorizza la somma, altrimenti int result = check_overflow(num1, num2); // Si è verificato un overflow se (risultato == -1) printf('Si è verificato un overflow del numero intero'); // Nessun overflow altrimenti printf('%d', risultato); restituire 0; } // Questo codice è stato fornito da sarajadhav12052009> Produzione
2147483647>
Allo stesso modo, possiamo verificare l'overflow sottraendo 2 numeri utilizzando INT_MIN.
Codici di errore di Linux
2. Calcolo di MIN in un array con elementi di grandi dimensioni
Di solito assegniamo un valore alto a MIN per calcolare il valore minimo in un array. Ma se un array ha elementi di grandi dimensioni, dobbiamo assegnare il valore più alto possibile all'array.
Di seguito l'implementazione:
Esempio
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); }> Produzione
2019403813>
Allo stesso modo, MAX può essere trovato in una matrice di numeri grandi utilizzando INT_MIN.
Domande frequenti su INT_MIN e INT_MAX
1. Perché abs(INT_MIN) non fornisce il risultato atteso?
Hai mai riscontrato un problema quando potresti aver utilizzato la funzione abs()? Molto probabilmente NO se non hai risolto alcun problema che richieda una funzione assoluta. Ma se hai risolto problemi su techcodeview.com o Leetcode, allora sai che c'è sempre un caso di test in cui fallisci e quel caso di test è quando hai il valore INT_MIN.
Vediamo cosa succede se utilizziamo la funzione assoluta che restituisce il valore mod, ovvero restituisce il seguente valore:
Java è vuoto
Valori del modulo
Ora, un'altra cosa che sappiamo è che l'intervallo di numeri interi va da -2.147.483.648 a 2.147.483.647 oppure possiamo dire che proviene da -2 31 a 2 31 -1 quindi come possiamo vedere che c'è sempre uno in più sul lato negativo rispetto a quello positivo
Vediamo ora cosa succede quando proviamo a prendere valori assoluti del risultato:
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; }> Produzione
Value of INT_MIN is: -2147483648 Value of abs(INT_MIN) is: -2147483648>
Ora possiamo osservare che abs(INT_MIN) è esso stesso INT_MIN e questo causa molti errori quando forniamo valutazioni online o risolviamo qualsiasi problema.
scarica video da youtube con vlc
Motivo
Ora se arriviamo alla parte del motivo possiamo vedere che attualmente abbiamo a che fare con la parte Integer e abs(integer) restituisce esso stesso un valore intero, quindi spostandosi accanto alla rappresentazione INT_MIN può essere rappresentato come
INT_MIN = -2147483648 = 10000000000000000000000000000000>
Qui il primo bit rappresenta il bit di segno che è impostato su uno, il che significa che è un numero negativo e la parte successiva è una rappresentazione binaria a 31 bit per 2147483648.
Ora se proviamo a prendere il valore assoluto di INT_MIN proverà a darci +2147483648 e questo valore non può essere rappresentato nella forma intera poiché il valore massimo che può essere rappresentato è +2147483647 poiché il lato positivo dobbiamo rappresentano 231 numeri interi ma è incluso anche 0, quindi l'intervallo da 1 a 2147483648 cambia da 0 a 2147483647 e per questo motivo abs(INT_MIN) non può essere rappresentato in questo intervallo e la risposta restituita è uguale a INT_MIN.
Soluzione
Bene, potrebbero esserci molte soluzioni al problema, ma alcune delle migliori soluzioni sono:
- Utilizza sempre un caso limite speciale per verificare if(x == INT_MIN) se stai utilizzando abs(x) e gestisci questo caso di conseguenza.
- Prova a utilizzare Long invece di INTEGER ma ricorda che anche LONG_MIN darà lo stesso risultato, quindi fai attenzione.