Existe-t-il du code pour trouver la valeur maximale de l'entier (en fonction du compilateur) en C / C ++ comme une Integer.MaxValue
fonction en java?
int
par la long long int
réponse de Gregories ...
-pedantic
) le supportent.
Existe-t-il du code pour trouver la valeur maximale de l'entier (en fonction du compilateur) en C / C ++ comme une Integer.MaxValue
fonction en java?
int
par la long long int
réponse de Gregories ...
-pedantic
) le supportent.
Réponses:
En C ++:
#include <limits>
puis utilisez
int imin = std::numeric_limits<int>::min(); // minimum value
int imax = std::numeric_limits<int>::max();
std::numeric_limits
est un type de modèle qui peut être instancié avec d'autres types:
float fmin = std::numeric_limits<float>::min(); // minimum positive value
float fmax = std::numeric_limits<float>::max();
En C:
#include <limits.h>
puis utilisez
int imin = INT_MIN; // minimum value
int imax = INT_MAX;
ou
#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
est la valeur positive minimale , alors que l'entier min
est la valeur minimale. Il en va de même pour les macros / constantes C.
uint64_t
et int64_t
, pas de int
.
#include <limits>
et int imax = std::numeric_limits<int>::max();
, mais j'obtiens l'erreur Can't resolve struct member 'max'
. Des idées sur pourquoi cela se produit et comment y remédier? J'utilise CLion IDE, avec CMake et C ++ 11 sur Ubuntu 14.04. Je pense que c'est lié à ce problème
Je sais que c'est une vieille question mais peut-être que quelqu'un peut utiliser cette solution:
int size = 0; // Fill all bits with zero (0)
size = ~size; // Negate all bits, thus all bits are set to one (1)
Jusqu'à présent, nous avons -1 comme résultat 'jusqu'à ce que la taille soit un entier signé.
size = (unsigned int)size >> 1; // Shift the bits of size one position to the right.
Comme le dit Standard, les bits décalés sont 1 si la variable est signée et négative et 0 si la variable serait non signée ou signée et positive.
Comme la taille est signée et négative, nous décalerions le bit de signe qui est 1, ce qui n'aide pas beaucoup, nous avons donc converti en unsigned int, forçant à passer à 0 à la place, définissant le bit de signe à 0 tout en laissant tous les autres bits rester à 1.
cout << size << endl; // Prints out size which is now set to maximum positive value.
Nous pourrions également utiliser un masque et un xor, mais nous devions ensuite connaître la taille exacte en bits de la variable. Avec le décalage des bits avant, nous n'avons pas besoin de savoir à tout moment combien de bits l'int a sur la machine ou le compilateur ni d'inclure des bibliothèques supplémentaires.
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()
- fonctionne également dans des contextes de modèle, mais (pour une raison insondable à mes yeux) ne peut pas être utilisé comme constante de compilation. INT_MAX
- est une macro, assez inutile dans les fonctions de modèle, mais peut être utilisée comme constante de compilation.
Voici une macro que j'utilise pour obtenir la valeur maximale des entiers signés, qui est indépendante de la taille du type d'entier signé utilisé, et pour laquelle gcc -Woverflow ne se plaindra pas
#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);
Pourquoi ne pas écrire un morceau de code comme:
int max_neg = ~(1 << 31);
int all_ones = -1;
int max_pos = all_ones & max_neg;
OK Je n'ai ni représentant pour commenter la réponse précédente (de Philippe De Muyter) ni augmenter son score, d'où un nouvel exemple utilisant son define pour SIGNED_MAX trivialement étendu pour les types non signés:
// 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;
Contrairement à l'utilisation de tel ou tel en-tête, nous utilisons ici le type réel du compilateur.
Qu'en est-il (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2))
. C'est la même chose que2^(8*sizeof(int)-2) - 1 + 2^(8*sizeof(int)-2)
.
Si 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]
.
Vous ne pouvez pas utiliser 2*(1 << (8*sizeof(int)-2)) - 1
car il débordera, mais (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2))
fonctionne.