valore massimo di int


177

Esiste un codice per trovare il valore massimo dell'intero (in base al compilatore) nella Integer.MaxValuefunzione simile a C / C ++ in Java?


1
c'è un modo per trovare il valore massimo di long long int ??
d3vdpro,

Sostituisci semplicemente intcon la long long intrisposta Gregories ...
Georg Fritzsche il

1
eccetto che long long non fa parte di C ++


@Neil, giusto, è il suo C99 - ma VC e GCC (senza -pedantic) lo supportano.
Georg Fritzsche,

Risposte:


323

In C ++:

#include <limits>

quindi utilizzare

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

std::numeric_limits è un tipo di modello che può essere istanziato con altri tipi:

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

In C:

#include <limits.h>

quindi utilizzare

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

o

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

13
Si noti che i virgola mobile minsono il valore positivo minimo , mentre come intero minè il valore minimo. Lo stesso vale per le macro / costanti C.
dalle

4
in C99 puoi anche usare UINT64_MAX e INT64_MAX
Dmitry Vyal

3
@DmitryVyal: Sì, puoi, ma quelli sono i limiti di uint64_te int64_t, non di int.
Keith Thompson,

In C ++, ho usato lo stesso codice mostrato sopra: #include <limits>e int imax = std::numeric_limits<int>::max();, ma ottengo l'errore Can't resolve struct member 'max'. Qualche idea sul perché ciò accada e su come risolverlo? Sto usando CLion IDE, con CMake e C ++ 11 su Ubuntu 14.04. Penso che sia collegato a questo problema
Modulitos,

1
Spero che questo aiuti qualcuno, perché è stato corretto un bug IDE di CLion usando l'ultimo CLion (build 138.2344 - CLion è nella fase del programma di accesso anticipato, e quindi instabile)
modulitos,

30

So che è una vecchia domanda, ma forse qualcuno può usare questa soluzione:

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

Finora abbiamo -1 come risultato 'finché la dimensione non è un int firmato.

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

Come dice Standard, i bit che vengono spostati sono 1 se la variabile è firmata e negativa e 0 se la variabile sarebbe senza segno o firmata e positiva.

Poiché la dimensione è firmata e negativa, spostiamo il bit di segno che è 1, il che non aiuta molto, quindi eseguiamo il cast di unsigned int, forzando invece a spostare 0, impostando il bit di segno su 0 lasciando tutti gli altri bit 1.

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

Potremmo anche usare una maschera e xor ma poi abbiamo dovuto conoscere l'esatta dimensione della variabile. Con lo spostamento in fronte dei bit, non dobbiamo sapere in alcun momento quanti bit ha int sulla macchina o sul compilatore, né abbiamo bisogno di includere librerie extra.


1
cout << "INT_MAX:\t" << (int) ((~((unsigned int) 0)) >> 1) << '\n' << "UINT_MAX:\t" << ~((unsigned int) 0) << endl;
Slaiyer,

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

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

1
Non definirei INT_MAX "una soluzione per C". È vecchio stile e deprecato in C ++, però.
Paul Tomblin,

6
Penso che entrambe siano risposte C ++. numeric_limits<int>::max()- funziona anche in contesti di template, ma (per qualche ragione insondabile per me) non può essere usato come costante di compilazione. INT_MAX- è una macro, piuttosto inutile all'interno delle funzioni del modello, ma può essere utilizzata come costante di compilazione.
UncleBens,

17
La cosa divertente è che numeric_limits <int> :: l'implementazione massima su msvc è simile al seguente: return (INT_MAX);
Nikola Smiljanić,

13
@paul Riferimento per l'ammortamento, per favore. E indovina come numeric_limits implementa max ()? Esatto, "return INT_MAX", almeno su GCC 4.4.0.

2
@UncleBens: le funzioni inline al momento non possono essere ridotte a espressioni costanti.
Georg Fritzsche,

1

Ecco una macro che uso per ottenere il valore massimo per numeri interi con segno, che è indipendente dalla dimensione del tipo intero con segno usato e per la quale gcc -Woverflow non si lamenterà

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

1

Perché non scrivere un pezzo di codice come:

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

28
Non esiste alcuna garanzia che int abbia una dimensione di 32 bit e non esiste alcuna garanzia sul formato intero negativo in memoria. Ancora meno importante, non è necessario fare in modo che le persone guardino '~'.
Sqeaky,

0

OK, non ho nessun rappresentante per commentare la risposta precedente (di Philippe De Muyter) né aumentare il suo punteggio, quindi un nuovo esempio usando la sua definizione per SIGNED_MAX banalmente estesa per tipi senza segno:

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

Diversamente dall'uso di questa o quella intestazione, qui usiamo il tipo reale dal compilatore.


0
#include <iostrema>

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

Potrebbe dipendere dall'architettura ma funziona almeno nella mia configurazione.


-1

Per il valore massimo specifico di int , di solito scrivo la notazione esadecimale:

int my_max_int = 0x7fffffff;

invece del valore decimale irregolare:

int my_max_int = 2147483647;

-1

Che dire (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2)). Questo è lo stesso di 2^(8*sizeof(int)-2) - 1 + 2^(8*sizeof(int)-2).

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

Non puoi usarlo 2*(1 << (8*sizeof(int)-2)) - 1perché traboccerà, ma (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2))funziona.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.