web-dev-qa-db-fra.com

valeur maximale de int

Existe-t-il un code permettant de trouver la valeur maximale d’entier (selon le compilateur) en C/C++, comme la fonction Integer.MaxValue en java?

c++cstllimitsnumeric-limits
151
d3vdpro

En C++:

#include <limits>

puis utiliser

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 utiliser

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;
286
Gregory Pakosz

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 size 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 size est signé et négatif, nous décalerions le bit de signe qui est 1, ce qui ne nous aide pas beaucoup. Nous avons donc basculé sur unsigned int, forçant à passer à 0 à la place. les bits restent 1.

cout << size << endl; // Prints out size which is now set to maximum positive value.

Nous pourrions aussi utiliser un masque et xor mais nous devions ensuite connaître la taille exacte de la variable. Avec le décalage avant en bits, nous n’avons à connaître à aucun moment le nombre de bits que l’int ait sur la machine ou le compilateur, ni avons besoin d’inclure des bibliothèques supplémentaires.

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

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

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;
2
Prabhu

Voici une macro que j'utilise pour obtenir la valeur maximale pour les 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);
2
Philippe De Muyter

D'ACCORD. Je n'ai pas de 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.

1
A. Genchev

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;
0
Hao
#include <iostrema>

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

Cela dépend peut-être de l'architecture, mais cela fonctionne au moins dans ma configuration.

0
macmur

Qu'en est-il de (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2)). C'est la même chose que 2^(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.

0
izanbf1803