För det mesta, i konkurrensutsatt programmering, finns det ett behov av att tilldela variabeln, det maximala eller lägsta värdet som datatypen kan hålla, men att komma ihåg ett så stort och exakt antal visar sig vara ett svårt jobb. Därför har C/C++ vissa makron för att representera dessa siffror, så att dessa kan tilldelas variabeln direkt utan att egentligen skriva in hela talet.
C/C++ tillhandahåller två sådana makron, nämligen INT_MAX och INT_MIN som representerar heltalsgränserna. Beroende på kompilatorn och C++-standarden kan du behöva inkludera rubrikfilen eller i din C- respektive C++-källkod. Så det är tillrådligt att inkludera denna rubrikfil för att använda makrona INT_MAX och INT_MIN. För ytterligare läsning om denna rubrikfil, hänvisa till den här artikeln .
INT_MAX i C/C++
INT_MAX är ett makro som anger att en heltalsvariabel inte kan lagra något värde utöver denna gräns. Den representerar maxvärdet för den övre gränsen av heltalsdatatypen i C/C++.
Värdet på INT_MAX är:
år in i kvartalen
- INT_MAX = 2147483647 (för 32-bitars heltal)
- INT_MAX = 9,223,372,036,854,775,807 (för 64-bitars heltal)
INT_MIN i C/C++
INT_MIN är ett makro som anger att en heltalsvariabel inte kan lagra något värde under denna gräns. Den representerar minimivärde eller nedre gräns av heltalsdatatypen.
Värdet på INT_MIN är:
- INT_MIN = – 2147483648 (för 32-bitars heltal)
- INT_MIN = – 9,223,372,036,854,775,808 (för 64-bitars heltal)
Notera: Värden på INT_MAX och INT_MIN kan variera från kompilator till kompilator. Följande är typiska värden i en kompilator där heltal lagras med 32 bitar.
java hej världen exempel
Exempel på INT_MIN och 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); }> Produktion
2147483647 -2147483648>
Tillämpningar av INT_MAX och INT_MIN
Följande är de viktigaste tillämpningarna för INT_MAX och INT_MIN
1. Kontrollera efter heltalsspill
Vi kan använda makrona INT_MIN och INT_MAX för att leta efter det signerade heltalsspillet. Exemplet nedan visar hur man gör.
Exempel
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) returnera -1; // Inget spill inträffade annars returnerar num1 + num2; } // Drivrutinskod int main() { // Summan av dessa siffror kommer att vara lika med INT_MAX // Om något av dem ökas med 1, kommer spill // att inträffa int num1 = 2147483627; int num2 = 20; // Resultatet är -1 om spill inträffade // Lagrar summan, annars int resultat = check_overflow(num1, num2); // Bräddning inträffade om (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) returnera -1; // Inget spill inträffade annars returnerar num1 + num2; } int main(void) { // Summan av dessa siffror kommer att motsvara // INT_MAX Om något av dem ökas med 1, kommer spill // att inträffa int num1 = 2147483627; int num2 = 20; // Resultatet är -1 om spill inträffade // Lagrar summan, annars int resultat = check_overflow(num1, num2); // Spill inträffade om (resultat == -1) printf('Heltalsspill inträffade'); // Inget spill annars printf('%d', resultat); returnera 0; } // Denna kod är bidragit av sarajadhav12052009> Produktion
2147483647>
På samma sätt kan vi kontrollera om det finns överflöd medan vi subtraherar 2 tal med INT_MIN.
2. Beräknar MIN i en array med stora element
Vi tilldelar vanligtvis ett högt värde till MIN för att beräkna minimivärdet i en array. Men om en array har stora element måste vi tilldela arrayen det högsta möjliga värdet.
Nedan är implementeringen:
Exempel
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); }> Produktion
2019403813>
På samma sätt kan MAX hittas i en array av stora tal med INT_MIN.
Vanliga frågor om INT_MIN och INT_MAX
1. Varför ger inte abs(INT_MIN) det förväntade resultatet?
Har du någonsin stött på ett problem när du kanske har använt abs()-funktionen? Med största sannolikhet NEJ om du inte har löst något problem som kräver en absolut funktion. Men om du har löst problem på techcodeview.com eller Leetcode så vet du att det alltid finns ett testfall där du misslyckas och det testfallet är när du har värdet som INT_MIN.
Låt oss se vad som händer om vi använder den absoluta funktionen den returnerar modvärdet vilket betyder att det returnerar följande värde:
shilpa shetty ålder
Modulvärden
En annan sak som vi vet är att intervallet för heltal är från -2 147 483 648 till 2 147 483 647 eller så kan vi säga att det är från -2 31 till 2 31 - 1 så som vi kan se att det finns alltid en mer på den negativa sidan än den positiva
govinda skådespelare
Låt oss nu se vad som händer när vi försöker ta absoluta värden av resultatet:
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; }> Produktion
Value of INT_MIN is: -2147483648 Value of abs(INT_MIN) is: -2147483648>
Nu kan vi observera att abs(INT_MIN) är själva INT_MIN, och detta gör att många fel uppstår när vi ger några onlinebedömningar eller löser något problem.
Anledning
Om vi nu kommer till orsaksdelen kan vi se att vi för närvarande har att göra med heltalsdelen och abs(heltal) returnerar ett heltalsvärde själv, så att flytta bredvid representationen INT_MIN kan representeras som
INT_MIN = -2147483648 = 10000000000000000000000000000000>
Här representerar den första biten teckenbiten som är satt till ett vilket betyder att det är ett negativt tal och nästa del är en 31-bitars binär representation för 2147483648.
Om vi nu försöker ta det absoluta värdet av INT_MIN kommer det att försöka ge oss +2147483648 och detta värde kan inte representeras i heltalsformen eftersom det maximala värdet som kan representeras är +2147483647, eftersom vi på den positiva sidan måste representerar 231 heltal men 0 ingår också så intervallet från 1 till 2147483648 ändras till 0 till 2147483647 och av denna anledning kan abs(INT_MIN) inte representeras i detta intervall och svaret som returneras är detsamma som INT_MIN.
Lösning
Tja, det kan finnas många lösningar på problemet men några av de bästa lösningarna är:
- Använd alltid ett speciellt kantfall för att kontrollera if(x == INT_MIN) om du använder abs(x) och hantera detta fall därefter.
- Försök att använda Long istället för INTEGER men kom ihåg att LONG_MIN också ger samma resultat så var försiktig.