Is er een code om de maximale waarde van integer (volgens de compiler) in C/C++ te vinden, zoals de functie Integer.MaxValuein java?
Antwoord 1, autoriteit 100%
In C++:
#include <limits>
gebruik dan
int imin = std::numeric_limits<int>::min(); // minimum value
int imax = std::numeric_limits<int>::max();
std::numeric_limitsis een sjabloontype dat kan worden geïnstantieerd met andere typen:
float fmin = std::numeric_limits<float>::min(); // minimum positive value
float fmax = std::numeric_limits<float>::max();
In C:
#include <limits.h>
gebruik dan
int imin = INT_MIN; // minimum value
int imax = INT_MAX;
of
#include <float.h>
float fmin = FLT_MIN; // minimum positive value
double dmin = DBL_MIN; // minimum positive value
float fmax = FLT_MAX;
double dmax = DBL_MAX;
Antwoord 2, autoriteit 9%
Ik weet dat het een oude vraag is, maar misschien kan iemand deze oplossing gebruiken:
int size = 0; // Fill all bits with zero (0)
size = ~size; // Negate all bits, thus all bits are set to one (1)
Tot nu toe hebben we -1 als resultaat ’till sizeis een ondertekend int.
size = (unsigned int)size >> 1; // Shift the bits of size one position to the right.
Zoals Standard zegt, zijn bits die naar binnen worden verschoven 1 als variabele is ondertekend en negatief en 0 als variabele niet-ondertekend of ondertekend en positief zou zijn.
Omdat grootteis ondertekend en negatief, zouden we in tekenbit verschuiven, wat 1 is, wat niet veel helpt, dus casten we naar niet-ondertekende int, waardoor we in plaats daarvan naar 0 moeten verschuiven en het tekenbit instellen naar 0 terwijl alle andere bits 1 blijven.
cout << size << endl; // Prints out size which is now set to maximum positive value.
We konden ook een masker en xor gebruiken, maar dan moesten we de exacte bitgrootte van de variabele weten. Met het verschuiven van bits vooraan, hoeven we op geen enkel moment te weten hoeveel bits de int op de machine of compiler heeft, noch hoeven we extra bibliotheken toe te voegen.
Antwoord 3, autoriteit 4%
#include <climits>
#include <iostream>
using namespace std;
int main() {
cout << INT_MAX << endl;
}
Antwoord 4
Hier is een macro die ik gebruik om de maximale waarde voor getekende gehele getallen te krijgen, die onafhankelijk is van de grootte van het gebruikte getekende gehele type, en waarvoor gcc -Woverflow niet zal klagen
#define SIGNED_MAX(x) (~(-1 << (sizeof(x) * 8 - 1)))
int a = SIGNED_MAX(a);
long b = SIGNED_MAX(b);
char c = SIGNED_MAX(c); /* if char is signed for this target */
short d = SIGNED_MAX(d);
long long e = SIGNED_MAX(e);
Antwoord 5
Waarom schrijf je niet een stukje code zoals:
int max_neg = ~(1 << 31);
int all_ones = -1;
int max_pos = all_ones & max_neg;
Antwoord 6
O.K. Ik heb geen vertegenwoordiger om commentaar te geven op het vorige antwoord (van Philippe De Muyter) noch de score te verhogen, vandaar een nieuw voorbeeld met zijn definevoor SIGNED_MAX, triviaal uitgebreid voor niet-ondertekende typen:
// We can use it to define limits based on actual compiler built-in types also:
#define INT_MAX SIGNED_MAX(int)
// based on the above, we can extend it for unsigned types also:
#define UNSIGNED_MAX(x) ( (SIGNED_MAX(x)<<1) | 1 ) // We reuse SIGNED_MAX
#define UINT_MAX UNSIGNED_MAX(unsigned int) // on ARM: 4294967295
// then we can have:
unsigned int width = UINT_MAX;
In tegenstelling tot het gebruik van deze of gene header, gebruiken we hier het echte type uit de compiler.
Antwoord 7
#include <iostrema>
int main(){
int32_t maxSigned = -1U >> 1;
cout << maxSigned << '\n';
return 0;
}
Het kan architectuurafhankelijk zijn, maar het werkt in ieder geval in mijn opstelling.
Antwoord 8
Hoe zit het met (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2)).
Dit is hetzelfde als 2^(8*sizeof(int)-2) - 1 + 2^(8*sizeof(int)-2).
Als sizeof(int) = 4 => 2^(8*4-2) - 1 + 2^(8*4-2) = 2^30 - 1 + 20^30 = (2^32)/2 - 1 [max signed int of 4 bytes].
Je kunt 2*(1 << (8*sizeof(int)-2)) - 1niet gebruiken omdat het overloopt, maar (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2))werkt.