valeur maximale de int


177

Existe-t-il du code pour trouver la valeur maximale de l'entier (en fonction du compilateur) en C / C ++ comme une Integer.MaxValuefonction en java?


1
y a-t-il un moyen de trouver la valeur maximale de long long int ??
d3vdpro

Remplacez simplement intpar la long long intréponse de Gregories ...
Georg Fritzsche

1
sauf que long long ne fait pas partie de C ++


@Neil, à droite, son C99 - mais VC et GCC (sans -pedantic) le supportent.
Georg Fritzsche

Réponses:


323

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;

13
Notez que la virgule flottante minest la valeur positive minimale , alors que l'entier minest la valeur minimale. Il en va de même pour les macros / constantes C.
dalle

4
dans C99, vous pouvez également utiliser UINT64_MAX et INT64_MAX
Dmitry Vyal

3
@DmitryVyal: Oui, vous pouvez, mais ce sont les limites de uint64_tet int64_t, pas de int.
Keith Thompson

En C ++, j'ai utilisé le même code ci-dessus: #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
modulitos

1
J'espère que cela aide quelqu'un, car c'était un bogue de l'IDE CLion que j'ai corrigé en utilisant le dernier CLion (build 138.2344 - CLion est dans la phase du programme d'accès anticipé, et donc instable)
modulitos

30

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.


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
Je n'appellerais pas INT_MAX "une solution pour C". C'est de la vieille école et obsolète en C ++, cependant.
Paul Tomblin

6
Je pense que les deux sont des réponses C ++. 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.
UncleBens

17
La chose amusante est que l'implémentation numeric_limits <int> :: max sur msvc ressemble à ceci: return (INT_MAX);
Nikola Smiljanić

13
@paul Référence pour la dépréciation s'il vous plaît. Et devinez comment numeric_limits implémente max ()? C'est vrai, "return INT_MAX", au moins sur GCC 4.4.0.

2
@UncleBens: les fonctions inline ne peuvent actuellement pas être réduites à des expressions constantes.
Georg Fritzsche

1

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

1

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;

28
Il n'y a aucune garantie que int a une taille de 32 bits et il n'y a aucune garantie sur le format entier négatif en mémoire. Moins important encore, il n'est pas nécessaire de forcer les gens à rechercher «~».
Sqeaky

0

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.


0
#include <iostrema>

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

Cela peut dépendre de l'architecture, mais cela fonctionne au moins dans ma configuration.


-1

Pour la valeur maximale spécifique de int , j'écris généralement la notation hexadécimale:

int my_max_int = 0x7fffffff;

au lieu de la valeur décimale irrégulière:

int my_max_int = 2147483647;

-1

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)) - 1car il débordera, mais (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2))fonctionne.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.