valeur maximale de int

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?

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;

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.

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

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

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.

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

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;

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.