Meestal is het bij competitief programmeren nodig om de variabele toe te wijzen, de maximale of minimale waarde die het gegevenstype kan bevatten, maar het onthouden van zo'n groot en nauwkeurig getal blijkt een lastige klus. Daarom heeft C/C++ bepaalde macro's om deze getallen weer te geven, zodat deze direct aan de variabele kunnen worden toegewezen zonder daadwerkelijk het hele getal te typen.
C/C++ biedt twee van dergelijke macro's, namelijk INT_MAX en INT_MIN, die de limieten voor gehele getallen vertegenwoordigen. Afhankelijk van de compiler en de C++-standaard kan het zijn dat u het headerbestand moet opnemen of in respectievelijk uw C- of C++-broncode. Het is dus raadzaam om dit headerbestand op te nemen voor het gebruik van de macro's INT_MAX en INT_MIN. Voor meer informatie over dit headerbestand, raadpleeg dit artikel .
INT_MAX in C/C++
INT_MAX is een macro die specificeert dat een integer-variabele geen enkele waarde boven deze limiet kan opslaan. Het vertegenwoordigt de maximale waarde van de bovengrens van het integer-gegevenstype in C/C++.
De waarde van INT_MAX is:
char + int in Java
- INT_MAX = 2147483647 (voor 32-bit gehele getallen)
- INT_MAX = 9.223.372.036.854.775.807 (voor 64-bit gehele getallen)
INT_MIN in C/C++
INT_MIN is een macro die specificeert dat een integer-variabele geen enkele waarde onder deze limiet kan opslaan. Het vertegenwoordigt de minimumwaarde of de ondergrens van het gegevenstype geheel getal.
De waarde van INT_MIN is:
- INT_MIN = – 2147483648 (voor 32-bit gehele getallen)
- INT_MIN = – 9.223.372.036.854.775.808 (voor 64-bit gehele getallen)
Opmerking: Waarden van INT_MAX en INT_MIN kunnen variëren van compiler tot compiler. Hieronder volgen typische waarden in een compiler waarbij gehele getallen worden opgeslagen met behulp van 32 bits.
Voorbeeld van INT_MIN en 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); }> Uitvoer
2147483647 -2147483648>
Toepassingen van INT_MAX en INT_MIN
Hieronder volgen de belangrijkste toepassingen van INT_MAX en INT_MIN
1. Controleer op overloop van gehele getallen
We kunnen de macro's INT_MIN en INT_MAX gebruiken om te controleren op de overloop van gehele getallen met teken. Het onderstaande voorbeeld laat zien hoe u dit moet doen.
snarenbouwer
Voorbeeld
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 - getal2) retourneert -1; // Er vond geen overloop plaats, anders retourneert num1 + num2; } // Stuurprogrammacode int main() {/ // De som van deze getallen is gelijk aan INT_MAX // Als een van deze getallen met 1 wordt verhoogd, zal overflow // plaatsvinden int num1 = 2147483627; int aantal2 = 20; // Resultaat is -1 als er een overflow heeft plaatsgevonden // Slaat de som op, anders int result = check_overflow(num1, num2); // Overloop vond plaats als (resultaat == -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 - getal2) retourneert -1; // Er vond geen overloop plaats, anders retourneert num1 + num2; } int main(void) {// De som van deze getallen zal gelijk zijn aan // INT_MAX Als een van deze getallen met 1 wordt verhoogd, zal overflow // plaatsvinden int num1 = 2147483627; int aantal2 = 20; // Resultaat is -1 als er een overflow heeft plaatsgevonden // Slaat de som op, anders int result = check_overflow(num1, num2); // Er is een overloop opgetreden als (resultaat == -1) printf('Overloop van een geheel getal heeft plaatsgevonden'); // Geen overloop anders printf('%d', resultaat); retour 0; } // Deze code is bijgedragen door sarajadhav12052009> Uitvoer
2147483647>
Op dezelfde manier kunnen we controleren op overloop terwijl we twee getallen aftrekken met behulp van INT_MIN.
2. MIN berekenen in een array met grote elementen
Meestal wijzen we een hoge waarde toe aan MIN om de minimumwaarde in een array te berekenen. Maar als een array grote elementen heeft, moeten we de hoogst mogelijke waarde aan de array toekennen.
Hieronder vindt u de implementatie:
Voorbeeld
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); }> Uitvoer
2019403813>
Op dezelfde manier kan MAX worden gevonden in een reeks grote getallen met behulp van INT_MIN.
Veelgestelde vragen over INT_MIN en INT_MAX
1. Waarom geeft abs(INT_MIN) niet het verwachte resultaat?
Heeft u ooit een probleem ondervonden toen u de functie abs() gebruikte? Hoogstwaarschijnlijk NEE als u geen enkel probleem hebt opgelost waarvoor een absolute functie vereist is. Maar als je problemen op techcodeview.com of Leetcode hebt opgelost, dan weet je dat er altijd één testcase is waarin je faalt en die testcase is wanneer je de waarde INT_MIN hebt.
Laten we eens kijken wat er gebeurt als we de absolute functie gebruiken, deze retourneert de mod-waarde, wat betekent dat deze de volgende waarde retourneert:
segmentatiefoutkern gedumpt
Moduluswaarden
Een ander ding dat we weten is dat het bereik van een geheel getal loopt van -2.147.483.648 tot 2.147.483.647, of we kunnen zeggen dat het van -2 31 naar 2 31 - 1 zodat we kunnen zien dat dat zo is altijd één meer aan de negatieve kant dan de positieve
Laten we nu eens kijken wat er gebeurt als we absolute waarden van het resultaat proberen te nemen:
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; }> Uitvoer
Value of INT_MIN is: -2147483648 Value of abs(INT_MIN) is: -2147483648>
Nu kunnen we zien dat abs(INT_MIN) zelf INT_MIN is, en dit zorgt ervoor dat er veel fouten optreden als we online beoordelingen geven of een probleem oplossen.
Reden
Als we nu bij het redengedeelte komen, kunnen we zien dat we momenteel te maken hebben met het geheeltallige gedeelte en abs(geheel getal) retourneert zelf een geheel getalwaarde, dus als we naast representatie INT_MIN gaan, kan dit worden weergegeven als
INT_MIN = -2147483648 = 10000000000000000000000000000000>
Hier vertegenwoordigt het eerste bit het tekenbit dat is ingesteld op één, wat betekent dat het een negatief getal is, en het volgende deel is een 31-bits binaire representatie voor 2147483648.
json van Java-object
Als we nu de absolute waarde van INT_MIN proberen te nemen, zal het proberen ons +2147483648 te geven en deze waarde kan niet worden weergegeven in de vorm van een geheel getal, aangezien de maximale waarde die kan worden weergegeven +2147483647 is, omdat we aan de positieve kant moeten vertegenwoordigen 231 gehele getallen, maar 0 is ook inbegrepen, dus het bereik van 1 tot 2147483648 verandert in 0 tot 2147483647 en om deze reden kan de abs(INT_MIN) niet in dit bereik worden weergegeven en is het geretourneerde antwoord hetzelfde als INT_MIN.
Oplossing
Er kunnen veel oplossingen voor het probleem zijn, maar enkele van de beste oplossingen zijn:
- Gebruik altijd een speciaal randgeval om te controleren of(x == INT_MIN) als u abs(x) gebruikt en behandel dit geval dienovereenkomstig.
- Probeer Long te gebruiken in plaats van INTEGER, maar onthoud dat LONG_MIN hetzelfde resultaat zal opleveren, dus wees voorzichtig.