it-swarm.com.de

maximalwert von int

Gibt es einen Code, um den maximalen Wert von Integer (entsprechend dem Compiler) in C/C++ zu ermitteln, wie Integer.MaxValue-Funktion in Java?

151
d3vdpro

In C++:

#include <limits>

dann benutze

int imin = std::numeric_limits<int>::min(); // minimum value
int imax = std::numeric_limits<int>::max();

std::numeric_limits ist ein Vorlagentyp, der mit anderen Typen instanziiert werden kann:

float fmin = std::numeric_limits<float>::min(); // minimum positive value
float fmax = std::numeric_limits<float>::max();

In C:

#include <limits.h>

dann benutze

int imin = INT_MIN; // minimum value
int imax = INT_MAX;

oder

#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;
286
Gregory Pakosz

Ich weiß, dass es eine alte Frage ist, aber vielleicht kann jemand diese Lösung verwenden:

int size = 0; // Fill all bits with zero (0)
size = ~size; // Negate all bits, thus all bits are set to one (1)

Bisher haben wir -1 als Ergebnis 'till size ist ein vorzeichenbehaftetes int.

size = (unsigned int)size >> 1; // Shift the bits of size one position to the right.

Wie Standard sagt, sind Bits, die hineingeschoben werden, 1, wenn die Variable vorzeichenbehaftet ist, und negativ, und 0, wenn die Variable unsigniert oder signiert und positiv wäre.

Da size vorzeichenbehaftet und negativ ist, würden wir das Vorzeichenbit (1) verschieben, was nicht viel hilft. Wir werden also in unsigned int umgewandelt und zwingen, stattdessen in 0 zu wechseln Bits bleiben 1.

cout << size << endl; // Prints out size which is now set to maximum positive value.

Wir könnten auch eine Maske und ein xor verwenden, aber dann mussten wir die genaue Bitgröße der Variablen kennen. Durch das Verschieben von Bits in Front müssen wir zu keinem Zeitpunkt wissen, wie viele Bits das int auf Machine oder Compiler hat, und wir müssen keine zusätzlichen Bibliotheken hinzufügen.

23
MJeB
#include <climits>
#include <iostream>
using namespace std;

int main() {
  cout << INT_MAX << endl;
}
15
anon

Warum schreibst du nicht ein Stück Code wie:

int  max_neg = ~(1 << 31);
int  all_ones = -1;
int max_pos = all_ones & max_neg;
2
Prabhu

Hier ist ein Makro, das ich verwende, um den Maximalwert für vorzeichenbehaftete Ganzzahlen zu erhalten, der unabhängig von der Größe des vorzeichenbehafteten Ganzzahlentyps ist und für den sich gcc -Woverflow nicht beschwert

#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);
2

OK. Ich habe weder einen Vertreter, um die vorherige Antwort (von Philippe De Muyter) zu kommentieren, noch seine Punktzahl zu erhöhen. Daher ein neues Beispiel, das sein define für SIGNED_MAX für unsignierte Typen trivial erweitert:

// 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;

Im Gegensatz zu diesem oder jenem Header verwenden wir hier den echten Typ des Compilers.

1
A. Genchev

Für den spezifischen Maximalwert von int schreibe ich normalerweise die hexadezimale Notation:

int my_max_int = 0x7fffffff;

anstelle des unregelmäßigen Dezimalwerts:

int my_max_int = 2147483647;
0
Hao
#include <iostrema>

int main(){
    int32_t maxSigned = -1U >> 1;
    cout << maxSigned << '\n';
    return 0;
}

Es kann architekturabhängig sein, funktioniert aber zumindest in meinem Setup.

0
macmur

Was ist mit (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2)). Dies ist das Gleiche wie 2^(8*sizeof(int)-2) - 1 + 2^(8*sizeof(int)-2).

Wenn 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].

Sie können 2*(1 << (8*sizeof(int)-2)) - 1 nicht verwenden, da dies überläuft, (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2)) jedoch funktioniert.

0
izanbf1803