Esiste un codice per trovare il valore massimo dell'intero (in base al compilatore) nella Integer.MaxValue
funzione simile a C / C ++ in Java?
int
con la long long int
risposta Gregories ...
-pedantic
) lo supportano.
Esiste un codice per trovare il valore massimo dell'intero (in base al compilatore) nella Integer.MaxValue
funzione simile a C / C ++ in Java?
int
con la long long int
risposta Gregories ...
-pedantic
) lo supportano.
Risposte:
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;
min
sono il valore positivo minimo , mentre come intero min
è il valore minimo. Lo stesso vale per le macro / costanti C.
uint64_t
e int64_t
, non di int
.
#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
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.
cout << "INT_MAX:\t" << (int) ((~((unsigned int) 0)) >> 1) << '\n' << "UINT_MAX:\t" << ~((unsigned int) 0) << endl;
#include <climits>
#include <iostream>
using namespace std;
int main() {
cout << INT_MAX << endl;
}
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.
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);
Perché non scrivere un pezzo di codice come:
int max_neg = ~(1 << 31);
int all_ones = -1;
int max_pos = all_ones & max_neg;
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.
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)) - 1
perché traboccerà, ma (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2))
funziona.