Maximalwert von int

Gibt es Code, um den Maximalwert der Ganzzahl (entsprechend dem Compiler) in einer C / C ++ - ähnlichen Integer.MaxValueFunktion in Java zu finden?

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;

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 'bis Größe ein vorzeichenbehaftetes int ist.

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

Wie Standard sagt, sind Bits, die verschoben werden, 1, wenn die Variable vorzeichenbehaftet und negativ ist, und 0, wenn die Variable vorzeichenlos oder vorzeichenbehaftet und positiv ist.

Da die Größe vorzeichenbehaftet und negativ ist, würden wir das Vorzeichenbit 1 verschieben, was nicht viel hilft. Daher wandeln wir in vorzeichenloses int um und erzwingen stattdessen eine Verschiebung in 0, wobei das Vorzeichenbit auf 0 gesetzt wird, während alle anderen Bits 1 bleiben.

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

Wir könnten auch eine Maske und xor verwenden, aber dann mussten wir die genaue Bitgröße der Variablen kennen. Beim Verschieben der Bits müssen wir zu keinem Zeitpunkt wissen, wie viele Bits der int auf dem Computer oder Compiler hat, und wir müssen keine zusätzlichen Bibliotheken einschließen.

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

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

Hier ist ein Makro, mit dem ich den Maximalwert für vorzeichenbehaftete Ganzzahlen erhalte, der unabhängig von der Größe des verwendeten vorzeichenbehafteten Ganzzahltyps 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);

Warum nicht einen Code schreiben wie:

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

OK, ich habe weder einen Repräsentanten, um die vorherige Antwort (von Philippe De Muyter) zu kommentieren, noch die Punktzahl zu erhöhen. Daher ein neues Beispiel, das seine Definition für SIGNED_MAX verwendet und für vorzeichenlose Typen trivial erweitert wurde:

// 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 zur Verwendung dieses oder jenes Headers verwenden wir hier den realen Typ aus dem Compiler.

#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.

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;

Wie wäre es mit (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2)) ist . Dies ist das gleiche wie2^(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 nicht verwenden, 2*(1 << (8*sizeof(int)-2)) - 1da es überläuft, aber (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2))funktioniert.