Det meste af tiden, i konkurrencepræget programmering, er der behov for at tildele variablen, den maksimale eller minimale værdi, som datatypen kan indeholde, men at huske et så stort og præcist tal viser sig at være en vanskelig opgave. Derfor har C/C++ visse makroer til at repræsentere disse tal, så disse kan tildeles direkte til variablen uden egentlig at indtaste hele tallet.
C/C++ giver to sådanne makroer, nemlig INT_MAX og INT_MIN, der repræsenterer heltalsgrænserne. Afhængigt af compileren og C++-standarden, kan du blive bedt om at inkludere header-filen eller i din C eller C++ kildekode hhv. Så det er tilrådeligt at inkludere denne overskriftsfil til brug af makroerne INT_MAX og INT_MIN. For yderligere læsning om denne header-fil, henvise til denne artikel .
INT_MAX i C/C++
INT_MAX er en makro, der specificerer, at en heltalsvariabel ikke kan lagre nogen værdi ud over denne grænse. Det repræsenterer maksimal værdi af den øvre grænse af heltalsdatatypen i C/C++.
Værdien af INT_MAX er:
c++ konverter int til streng
- INT_MAX = 2147483647 (for 32-bit heltal)
- INT_MAX = 9.223.372.036.854.775.807 (for 64-bit heltal)
INT_MIN i C/C++
INT_MIN er en makro, der specificerer, at en heltalsvariabel ikke kan lagre nogen værdi under denne grænse. Det repræsenterer minimumsværdi eller nedre grænse af heltalsdatatypen.
Værdien af INT_MIN er:
- INT_MIN = – 2147483648 (for 32-bit heltal)
- INT_MIN = – 9.223.372.036.854.775.808 (for 64-bit heltal)
Bemærk: Værdier for INT_MAX og INT_MIN kan variere fra compiler til compiler. Følgende er typiske værdier i en compiler, hvor heltal er gemt ved hjælp af 32 bit.
smide kast i java
Eksempel på INT_MIN og 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>
Anvendelser af INT_MAX og INT_MIN
Følgende er de vigtigste anvendelser af INT_MAX og INT_MIN
1. Tjek for heltalsoverløb
Vi kan bruge makroerne INT_MIN og INT_MAX til at kontrollere for det signerede heltalsoverløb. Eksemplet nedenfor viser, hvordan du gør det.
Eksempel
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) returner -1; // Intet overløb opstod ellers returner num1 + num2; } // Driverkode int main() { // Summen af disse tal vil være lig med INT_MAX // Hvis nogen af dem øges med 1, vil overløb // forekomme int num1 = 2147483627; int num2 = 20; // Resultat er -1 hvis overløb opstod // Gemmer summen, ellers int resultat = check_overflow(tal1, tal2); // Overløb opstod, hvis (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) returner -1; // Intet overløb opstod ellers returner num1 + num2; } int main(void) { // Summen af disse tal vil svare til // INT_MAX Hvis nogen af dem øges med 1, vil overløb // forekomme int num1 = 2147483627; int num2 = 20; // Resultat er -1 hvis overløb opstod // Gemmer summen, ellers int resultat = check_overflow(tal1, tal2); // Overløb opstod hvis (resultat == -1) printf('Heltalsoverløb opstod'); // Intet overløb ellers printf('%d', resultat); retur 0; } // Denne kode er bidraget af sarajadhav12052009> Produktion
2147483647>
På samme måde kan vi kontrollere for overløb, mens vi trækker 2 tal fra ved hjælp af INT_MIN.
2. Beregning af MIN i et array med store elementer
Vi tildeler normalt en høj værdi til MIN for at beregne minimumsværdien i et array. Men hvis et array har store elementer, skal vi tildele arrayet den højest mulige værdi.
Nedenfor er implementeringen:
Eksempel
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å samme måde kan MAX findes i en række store tal ved hjælp af INT_MIN.
Ofte stillede spørgsmål om INT_MIN og INT_MAX
1. Hvorfor giver abs(INT_MIN) ikke det forventede resultat?
Har du nogensinde stået over for et problem, når du måske har brugt abs()-funktionen? Sandsynligvis NEJ, hvis du ikke har løst noget problem, som kræver en absolut funktion. Men hvis du har løst problemer på techcodeview.com eller Leetcode, så ved du, at der altid er en testcase, hvor du fejler, og den testcase er, når du har værdien som INT_MIN.
Lad os se, hvad der sker, hvis vi bruger den absolutte funktion, den returnerer modværdien, hvilket betyder, at den returnerer følgende værdi:
lister i java
Modulværdier
En anden ting, vi ved, er, at intervallet for heltal er fra -2.147.483.648 til 2.147.483.647, eller vi kan sige, at det er fra -2 31 til 2 31 - 1 så som vi kan se, at der er altid en mere på den negative side end den positive
deterministiske endelige automater
Lad os nu se, hvad der sker, når vi forsøger at tage absolutte værdier af 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 observere, at abs(INT_MIN) er selve INT_MIN, og dette forårsager, at der opstår mange fejl, når vi giver nogen online vurderinger eller løser ethvert problem.
Grund
Hvis vi nu kommer til årsagsdelen, kan vi se, at vi i øjeblikket har at gøre med heltalsdelen, og abs(heltal) returnerer selv en heltalsværdi, så flytning ved siden af repræsentationen INT_MIN kan repræsenteres som
INT_MIN = -2147483648 = 10000000000000000000000000000000>
Her repræsenterer 1. bit fortegnsbitten, som er sat til én, hvilket betyder, at det er et negativt tal, og den næste del er en 31-bit binær repræsentation for 2147483648.
Hvis vi nu prøver at tage den absolutte værdi af INT_MIN, vil det forsøge at give os +2147483648, og denne værdi kan ikke repræsenteres i heltalformen, da den maksimale værdi, der kan repræsenteres, er +2147483647, da vi på den positive side skal repræsentere 231 heltal, men 0 er også inkluderet, så intervallet fra 1 til 2147483648 ændres til 0 til 2147483647, og af denne grund kan abs(INT_MIN) ikke repræsenteres i dette interval, og det returnerede svar er det samme som INT_MIN.
Løsning
Nå, der kan være mange løsninger på problemet, men nogle af de bedste løsninger er:
- Brug altid en speciel kantkasse til at kontrollere if(x == INT_MIN), hvis du bruger abs(x), og håndter denne sag derefter.
- Prøv at bruge Long i stedet for INTEGER, men husk, at LONG_MIN også giver det samme resultat, så vær forsigtig.