web-dev-qa-db-fra.com

Plage de valeurs en C Int et Long 32 - 64 bits

Je suis confondu avec la plage de valeurs de la variable Int en C.

Je sais que 32 bits non signés int ont une gamme de: 0 à 65 535 . Si longtemps a 0 à 4 294 967 295

C'est bien dans la machine 32bits. Mais maintenant, dans les machines 64bits, tout reste-t-il identique?

Je comprends ces questions en tant que débutant, mais je suis vraiment confus. Cette signature de méthode n'aide pas trop. :)

unsigned long long int atomicAdd(unsigned long long int* address, unsigned long long int val);
cint32bit-64bit
42
Custodio

En C et C++, vous avez ces exigences minimales (c’est-à-dire que les implémentations réelles peuvent avoir des grandeurs plus grandes)

signed char: -2^07+1 to +2^07-1
short:       -2^15+1 to +2^15-1
int:         -2^15+1 to +2^15-1
long:        -2^31+1 to +2^31-1
long long:   -2^63+1 to +2^63-1

Maintenant, sur des implémentations particulières, vous avez une variété de plages de bits. L'article de wikipedia le décrit bien.

65
Johannes Schaub - litb

Non, int en C est pas défini comme étant 32 bits. int et long ne sont pas définis comme ayant une taille spécifique. La seule chose que le langage garantit est que sizeof(char)<=sizeof(short)<=sizeof(long). 

Théoriquement, un compilateur pourrait faire short, char et long tout le même nombre de bits. Je connais certains qui ont réellement fait cela pour tous ces types sauf char.

C'est pourquoi C définit maintenant des types tels que uint16_t et uint32_t. Si vous avez besoin d'une taille spécifique, vous êtes censé en utiliser une.

18
T.E.D.

Extrait de K & R:

short est souvent 16 bits, long 32 bits et int 16 bits ou 32 bits. Chaque compilateur est libre de choisir les tailles appropriées pour ses propres matériel, sous réserve uniquement de la restriction que shorts et ints soient au moins 16 bits, longs au moins 32 bits et short à non. plus long que int, lequel n’est pas plus long que long.

Vous pouvez utiliser limits.h qui contient la définition des limites pour les types decimal/float:

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <float.h>


int main(int argc, char** argv) {

    printf("CHAR_BIT    :   %d\n", CHAR_BIT);
    printf("CHAR_MAX    :   %d\n", CHAR_MAX);
    printf("CHAR_MIN    :   %d\n", CHAR_MIN);
    printf("INT_MAX     :   %d\n", INT_MAX);
    printf("INT_MIN     :   %d\n", INT_MIN);
    printf("LONG_MAX    :   %ld\n", (long) LONG_MAX);
    printf("LONG_MIN    :   %ld\n", (long) LONG_MIN);
    printf("SCHAR_MAX   :   %d\n", SCHAR_MAX);
    printf("SCHAR_MIN   :   %d\n", SCHAR_MIN);
    printf("SHRT_MAX    :   %d\n", SHRT_MAX);
    printf("SHRT_MIN    :   %d\n", SHRT_MIN);
    printf("UCHAR_MAX   :   %d\n", UCHAR_MAX);
    printf("UINT_MAX    :   %u\n", (unsigned int) UINT_MAX);
    printf("ULONG_MAX   :   %lu\n", (unsigned long) ULONG_MAX);
    printf("USHRT_MAX   :   %d\n", (unsigned short) USHRT_MAX);
    printf("FLT_MAX     :   %g\n", (float) FLT_MAX);
    printf("FLT_MIN     :   %g\n", (float) FLT_MIN);
    printf("-FLT_MAX    :   %g\n", (float) -FLT_MAX);
    printf("-FLT_MIN    :   %g\n", (float) -FLT_MIN);
    printf("DBL_MAX     :   %g\n", (double) DBL_MAX);
    printf("DBL_MIN     :   %g\n", (double) DBL_MIN);
    printf("-DBL_MAX     :  %g\n", (double) -DBL_MAX);

    return (EXIT_SUCCESS);
}

Vous devrez peut-être modifier légèrement votre machine, mais c'est un bon modèle pour commencer à avoir une idée des valeurs min et max (définies par l'implémentation).

17
Ely

Il n'y a pas une réponse. La norme définit les plages minimales. Un int doit pouvoir contenir au moins 65535. Cependant, la plupart des compilateurs modernes permettent aux ints d'être des valeurs 32 bits. De plus, rien n'empêche plusieurs types d'avoir la même capacité (par exemple, int et long). 

Cela étant dit, la norme indique dans votre cas particulier:

0 → +18446744073709551615

comme gamme pour unsigned long long int.

Pour en savoir plus: http://en.wikipedia.org/wiki/C_variable_types_and_declarations#Size

9
Joe

En C et C++, exigences de mémoire de certaines variables:

signed char: -2^07 to +2^07-1
short: -2^15 to +2^15-1
int: -2^15 to +2^15-1
long: -2^31 to +2^31-1
long long: -2^63 to +2^63-1 

signed char: -2^07 to +2^07-1
short: -2^15 to +2^15-1
int: -2^31 to +2^31-1
long: -2^31 to +2^31-1
long long: -2^63 to +2^63-1 

dépend du compilateur et de l'architecture du matériel

La norme internationale pour le langage C exige seulement que la taille des variables courtes soit inférieure ou égale à la taille du type int, qui à son tour doit être inférieure ou égale à la taille du type long.

2
Vipin Diwakar

En fait, la plupart des processeurs modernes non signés (ARM, Intel/AMD, Alpha, SPARC, Itanium, PowerPC) auront une plage allant de 0 à 2 ^ 32 - 1, ce qui correspond à 4 294 967 295 = 0xffffffff non signé) aura une longueur de 32 bits et le plus grand est celui indiqué.

(short non signé aura une valeur maximale de 2 ^ 16 - 1 = 65 535)

(unsigned) long long int aura une longueur de 64 bits (long int suffira sous la plupart des Linux 64 bits, etc., mais la norme promet 64 bits pour long long int) . Par conséquent, ceux-ci ont la plage 0 à 2 ^ 64 - 1 = 18446744073709551615

2
Henno Brandsma

Examinez le fichier limits.h de votre système, il indiquera les limites spécifiques du système. Ou cochez man limits.h et allez à la section "Limites numériques".

1
phoxis

Jetez un coup d'œil à limits.h . Vous pouvez trouver les valeurs spécifiques pour votre compilateur. INT_MIN et INT_MAX seront d'intérêt. 

1
Paul Rubel

Un int non signé de 32 bits a une plage allant de 0 à 4 294 967 295. 0 à 65535 serait un 16 bits non signé.

Une longue longue non signée (et, sur une implémentation 64 bits, peut-être aussi ulong et éventuellement aussi bien) ont une plage64-1). En théorie, il pourrait être supérieur à cela, mais au moins pour le moment, c'est rare à inexistant.

0
Jerry Coffin