le maximum de valeur de type int

Est-il un code pour trouver la valeur maximale d'un entier (en conséquence pour le compilateur en C/C++ comme Integer.MaxValue fonction en java?

est-il possible de trouver la valeur max de long long int??
Il suffit de remplacer int avec long long int dans Gregories de réponse...
sauf que long ne fait pas partie de C++
En double, par exemple stackoverflow.com/questions/1732011/c-max-integer
droit, son C99 - mais VC et GCC (sans -pedantic) en charge.
Ne pas confondre int avec "integer". Il existe plusieurs types integer; int est juste l'un d'eux.

InformationsquelleAutor d3vdpro | 2009-12-06

c c++limits numeric-limits stl

294

En C++:
```
#include <limits>
```
ensuite 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();
```
Dans C:
```
#include <limits.h>
```
ensuite 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;
```
- Notez que la virgule flottante min sont le minimum positif de valeur, où l'entier min sont la valeur minimale. En va de même pour le C macros/constantes.
- en C99, vous pouvez également utiliser UINT64_MAX et INT64_MAX
- Oui vous pouvez, mais ce sont les limites de uint64_t et int64_t, pas de int.
- En C++, j'ai utilisé le même code ci-dessus: #include <limits> et int imax = std::numeric_limits<int>::max();, mais je reçois l'erreur Can't resolve struct member 'max'. Toutes les idées pour lesquelles cela se produit, et comment le résoudre? Je suis à l'aide de CLion IDE, avec CMake et C++ 11 sur Ubuntu 14.04. Je pense que c'est lié à ce problème
- Espérons que cela aide quelqu'un, parce que c'était un CLion IDE bug que j'ai corrigé à l'aide de la dernière CLion (build 138.2344 - CLion est dans le Programme d'Accès anticipé de phase, et donc instable)
- une façon élégante serait comme si (unsigned)-1/2
InformationsquelleAutor Gregory Pakosz
25

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 suite, jusqu'à ce taille est une signature de type int.
```
size = (unsigned int)size >> 1; //Shift the bits of size one position to the right.
```
Standard dit, les bits sont décalés dans sont 1 si la variable est signé et négatif et 0 si la variable serait non signé ou signé et positive.

Comme taille est signé et négatifs nous décalage de bit de signe, qui est de 1, ce qui ne l'aide pas beaucoup, de sorte que nous avons exprimées à unsigned int, la forçant à se déplacer dans 0 au lieu de cela, le réglage du bit de signe à 0 tout en laissant tous les autres bits restent 1.
```
cout << size << endl; //Prints out size which is now set to maximum positive value.
```
On peut aussi utiliser un masque et xor mais ensuite nous avons eu à connaître l'exacte bitsize de la variable. Avec le décalage de bits à l'avant, nous n'avons pas de savoir à tout moment combien de bits int a sur la machine ou le compilateur, ni besoin de nous comporter d'autres bibliothèques.
- cout << "INT_MAX:\t" << (int) ((~((unsigned int) 0)) >> 1) << '\n' << "UINT_MAX:\t" << ~((unsigned int) 0) << endl;
InformationsquelleAutor MJeB
15
```
#include <climits>
#include <iostream>
using namespace std;

int main() {
  cout << INT_MAX << endl;
}
```
- Je ne dirais pas INT_MAX "une solution pour C". C'est de la vieille école et obsolète en C++, si.
- Je pense que les deux sont en C++ réponses. numeric_limits<int>::max() - fonctionne aussi en modèle de contextes, mais (pour certains insondable raison pour moi) ne peut pas être utilisé comme une constante de compilation. INT_MAX - est une macro, assez inutile dans le modèle des fonctions, mais peut être utilisé comme une constante de compilation.
- Le plus drôle, c'est que numeric_limits<int>::max la mise en œuvre sur msvc ressemble à ceci: retour (INT_MAX);
- De référence pour le retrait s'il vous plaît. Et devinez comment numeric_limits implémente max()? C'est vrai, "retour INT_MAX", au moins sur GCC 4.4.0.
- les fonctions inline actuellement ne peut pas être réduite à des expressions constantes.
- Oui, j'ai compris que ça doit être une fonction en premier lieu parce que numeric_limits doit être utilisable pour les non-types d'entiers ainsi.
- En C++1x ils peuvent, à l'aide de constexpr.
- Mais la plupart des compilateurs encore ne prennent pas en charge constexpr suffisamment.
InformationsquelleAutor

Voici une macro-je utiliser pour obtenir la valeur maximale pour les entiers signés, qui est indépendante de la taille de l'entier signé de type utilisé, et pour le gcc -Woverflow ne se plaignent

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

InformationsquelleAutor Philippe De Muyter

2

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;
```
- Il n'y a aucune garantie que l'int est de 32 bits et il n'y a aucune garantie quant à la mémoire négative format de nombre entier. Moins important, il n'est pas nécessaire de rendre les gens à consulter '~'.
InformationsquelleAutor Prabhu

O. K. je ne pas avoir rep de commentaire sur la réponse précédente (de Philippe De Muyter), ni le lever du score, donc un nouvel exemple à l'aide de son définir 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 cette ou cet en-tête, ici, nous utilisons le type réel du compilateur.

InformationsquelleAutor A. Genchev

0

Pour la valeur maximale de int, j'ai l'habitude d'écrire la notation hexadécimale:
```
int my_max_int = 0x7fffffff;
```
au lieu de l'irrégularité de la valeur décimale:
```
int my_max_int = 2147483647;
```
InformationsquelleAutor Hao
0

Ce sujet (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2)).
C'est le même 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 elle déborde, mais (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2)) œuvres.

InformationsquelleAutor izanbf1803

#include <iostrema>

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

Il pourrait être dépendants de l'architecture, mais il ne le travail, au moins dans mon installation.

InformationsquelleAutor macmur

Vous devez vous connecter pour publier un commentaire.