valore massimo di int
-
13-09-2019 - |
Domanda
Esiste un codice per trovare il valore massimo di numero intero (di conseguenza per il compilatore) in C / C ++ come la funzione Integer.MaxValue
in java?
Soluzione
In C ++:
#include <limits>
quindi usare
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 usare
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;
Altri suggerimenti
Lo so che è una vecchia questione, ma forse qualcuno può utilizzare 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 'fino a size è 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 in sono 1 se la variabile è firmato e negativo e 0 se la variabile sarebbe senza segno o firmati e positivo.
size è firmato e negativo che si sposterebbe in bit di segno che è 1, che non sta aiutando molto, così abbiamo gettato a unsigned int, costringendo a spostare a 0, invece, l'impostazione del bit di segno a 0 mentre lasciando tutti gli altri bit rimangono 1.
cout << size << endl; // Prints out size which is now set to maximum positive value.
Si potrebbe anche usare una maschera e XOR, ma poi abbiamo dovuto conoscere l'esatta Bitsize della variabile. Con lo spostamento in bit davanti, non abbiamo di conoscere in qualsiasi momento il numero di bit int ha sulla macchina o compilatore né bisogno includiamo librerie extra.
#include <climits>
#include <iostream>
using namespace std;
int main() {
cout << INT_MAX << endl;
}
Ecco una macro che uso per ottenere il valore massimo per interi con segno, che è indipendente dalla dimensione del tipo intero con segno utilizzato, e per i quali gcc -Woverflow non si lamentano
#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);
Perché non scrivere un pezzo di codice come:
int max_neg = ~(1 << 31);
int all_ones = -1;
int max_pos = all_ones & max_neg;
O.K. Io non ho rep commentare risposta precedente (di Philippe De Muyter), né sollevare è il punteggio, quindi un nuovo esempio usando il suo definire per SIGNED_MAX banalmente esteso per i 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;
A differenza di questo o quel colpo di testa, qui usiamo il tipo reale dal compilatore.
Per la specifica valore massimo di int , io di solito scrivo la notazione esadecimale:
int my_max_int = 0x7fffffff;
invece del valore decimale irregolare:
int my_max_int = 2147483647;
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 è possibile utilizzare 2*(1 << (8*sizeof(int)-2)) - 1
perché traboccherà, ma (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2))
funziona.
#include <iostrema>
int main(){
int32_t maxSigned = -1U >> 1;
cout << maxSigned << '\n';
return 0;
}
Potrebbe essere dipendenti da architettura, ma funziona almeno nella mia messa a punto.