Gamme de valeurs en C Int et Long 32-64 bits
je suis confondu avec l'intervalle des valeurs de la variable Int en C.
je sais qu'un 32bits int non signé ont une gamme de: 0 à 65,535. Si longtemps a 0 à 4 294 967 295
c'est très bien dans la machine 32bits. Mais dans les machines 64bits, tout est pareil? Ou peut-être que ma capacité d'int est différente?
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);
10 réponses
en C et c++ Vous avez ces exigences (I. 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 les implémentations particulières, vous avez une variété de plages de bits. article de wikipédia décrit ceci gentiment.
Non, int en C défini à 32 bits. int et long ne sont pas définis à toute taille spécifique. La seule chose que la langue garanties sizeof(char)<=sizeof(short)<=sizeof(long).
Théoriquement un compilateur pourrait faire short,char et long tous le même nombre de bits. Je sais que quelques-unes en fait, n'a que pour tous ces types de sauvegardechar.
C'est pourquoi C définit maintenant des types comme uint16_t et uint32_t. Si vous besoin d'une taille spécifique, vous êtes censé utiliser l'un de ces.
extrait de K&R:
shortest souvent 16 bits,long32 bits etintsoit 16 bits ou 32 bits. Chaque compilateur est libre de choisir les tailles appropriées pour ses propres matériel, sous la seule réserve de la restriction deshortetintau moins 16 bits,longs sont au moins 32 bits, etshortne plus queint, qui n'est plus que delong.
vous pouvez utiliser limits.h que contient la définition des limites pour les types décimal/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);
}
peut-être que vous devrez peaufiner un peu votre machine, mais c'est un bon modèle pour commencer à avoir une idée des valeurs (implémentation-defined) min et max.
Il n'y a pas de réponse unique. La norme définit des fourchettes minimales. Un int doit pouvoir contenir au moins 65535. La plupart des compilateurs modernes permettent cependant des valeurs ints à 32 bits. En outre, rien n'empêche plusieurs types d'avoir la même capacité (par exemple int et long).
cela étant dit, la norme dit dans votre cas particulier:
0 → +18446744073709551615
comme la gamme pour non signé long int.
lecture: http://en.wikipedia.org/wiki/C_variable_types_and_declarations#Size
en fait, l'int non signé sur la plupart des processeurs modernes (ARM, Intel / AMD, Alpha, SPARC ,Itanium, PowerPC) aura une gamme de 0 à 2^32-1 qui est 4,294,967,295 = 0xffffff parce que int (à la fois signé et non signé) sera de 32 bits de long et le plus grand est comme indiqué.
(le court-métrage non signé aura une valeur maximale 2^16 - 1 = 65,535 )
(non signé) long long int aura une longueur de 64 bits (long int sera suffisant dans la plupart des Linuxes 64 bits, etc, mais la norme promesses 64 bits de long long int). Par conséquent, ceux - ci ont la gamme 0 à 2^64-1 = 18446744073709551615
En C et C++ besoins en mémoire d'une variable :
signed char: -2^07 to +2^07-1short: -2^15 to +2^15-1int: -2^15 to +2^15-1long: -2^31 to +2^31-1long long: -2^63 to +2^63-1
signed char: -2^07 to +2^07-1short: -2^15 to +2^15-1int: -2^31 to +2^31-1long: -2^31 to +2^31-1long long: -2^63 to +2^63-1
dépend du compilateur et de l'architecture matérielle
la norme internationale pour la langue C exige seulement que la taille court variables doit être inférieure ou égale à la taille de type int, qui à son tour doit être inférieure ou égale à la taille de type long.
regardez limites.h. Vous pouvez trouver les valeurs spécifiques pour votre compilateur. INT_MIN et INT_MAX seront intéressants.
regardez limits.h fichier dans votre système il indiquera les limites spécifiques du système. Ou vérifier man limits.h et allez à la section" limites numériques".
a 32-bit un int non signé a une gamme de 0 à 4 294 967 295. 0 à 65535 serait un 16-bit non signé.
un long long non signé (et, sur une implémentation 64 bits, peut-être aussi ulong et peut-être aussi uint) ont une portée (au moins) de 0 à 18,446,744,073,709,551,615 (2 64-1). En théorie, il pourrait être plus important que cela, mais au moins, pour l'instant c'est rare, voire inexistante.
Il est préférable d'inclure stdlib.h. Puisque sans stdlibg il faut aussi longtemps!--2-->