Quelle est la différence entre int, Int16, Int32 et Int64?

229

Quelle est la différence entre int, System.Int16, System.Int32et d' System.Int64autres que leurs tailles?

c# .net Joby Kurian
la source

Réponses:

348

Chaque type d'entier a une plage de capacité de stockage différente

   Type      Capacity

   Int16 -- (-32,768 to +32,767)

   Int32 -- (-2,147,483,648 to +2,147,483,647)

   Int64 -- (-9,223,372,036,854,775,808 to +9,223,372,036,854,775,807)

Comme l'a déclaré James Sutherland dans sa réponse :

intet Int32sont en effet synonymes; intsera un peu plus familier, Int32rend les 32 bits plus explicites pour ceux qui lisent votre code. Je serais enclin à utiliser int où j'ai juste besoin d'un `` entier '', Int32où la taille est importante (code cryptographique, structures) afin que les futurs responsables sachent qu'il est sûr d'agrandir un intsi approprié, mais devrait prendre soin de changerInt32 variables de la même manière .

Le code résultant sera identique: la différence est purement liée à la lisibilité ou à l'apparence du code.

Communauté
la source
1
Si vous savez que la valeur ne dépassera pas 65 535 (signé) ou −32 768 à 32 767 (non signé), ne vaudrait-il pas mieux définir l'entier int16pour économiser les ressources mémoire, plutôt que de simplement utiliser int?
2014
8
int et int32 peuvent également être synonymes, mais ils ne doivent pas nécessairement l'être. De nos jours, la plupart des systèmes vendus sont en 64 bits, auquel cas un int sera de 64 bits.
Martijn Otto
4
Pour Matthew T. Baker et tous les autres comme moi qui sont venus ici pour essayer de décider lequel utiliser du point de vue des performances, vous devriez consulter cet article qui suggère qu'Integer est plus efficace que Int16 dans de nombreux cas: stackoverflow.com/questions/129023/ net-integer-vs-int16
Tony L.
19
@MartijnOtto La question est étiquetée C #. En C #, intc'est toujours Int32 , quel que soit le système. Vous pensez peut-être au C ++?
9
@MattBaker: En général, sur les ordinateurs modernes, un int16 prend autant d'espace qu'un int32 (et en fait un int64), car pour que la plupart des opérations soient efficaces, nous remplissons les données pour aligner les accès sur les limites de 32 ou 64 bits (en modes 32 ou 64 bits respectivement). En effet, les accès non alignés sont ridiculement inefficaces sur certaines architectures et impossibles sur d'autres.
Joel
118

La seule vraie différence ici est la taille. Tous les types int ici sont des valeurs entières signées qui ont des tailles variables

  • Int16: 2 octets
  • Int32et int: 4 octets
  • Int64 : 8 octets

Il y a une petite différence entre Int64 et le reste. Sur une plate-forme 32 bits, les affectations à un Int64emplacement de stockage ne sont pas garanties atomiques. Il est garanti pour tous les autres types.

JaredPar
la source
Si je l' utilise Int64dans 32 bit Windows Operating Systemquels sont alors les questions que je pourrais faire face? Y a-t-il un exemple?
shaijut
70

int

Il s'agit d'un type de données primitif défini en C #.

Il est mappé sur Int32 de type FCL.

Il s'agit d'un type de valeur et représente la structure System.Int32.

Il est signé et prend 32 bits.

Il a une valeur minimale de -2147483648 et maximale de +2147483647.

Int16

Il s'agit d'un type FCL.

En C #, short est mappé sur Int16.

Il s'agit d'un type de valeur et représente la structure System.Int16.

Il est signé et prend 16 bits.

Il a une valeur minimale de -32768 et maximale de +32767.

Int32

Il s'agit d'un type FCL.

En C #, int est mappé sur Int32.

Il s'agit d'un type de valeur et représente la structure System.Int32.

Il est signé et prend 32 bits.

Il a une valeur minimale de -2147483648 et maximale de +2147483647.

Int64

Il s'agit d'un type FCL.

En C #, long est mappé sur Int64.

Il s'agit d'un type de valeur et représente la structure System.Int64.

Il est signé et prend 64 bits.

Il a une valeur minimale de 9 223 372 036 854 775 808 et maximale de 9 223 372 036 854 775 807.

Haris
la source
Il suffit d'ajouter que le Int64type de données peut être représenté à l' aide Lou le lsuffixe tout Int16ou Int32pas suffixe en C #.
RBT
14

Selon Jeffrey Richter (l'un des contributeurs du développement du framework .NET) 'CLR via C #':

int est un type primitif autorisé par le compilateur C #, tandis que Int32 est le type de bibliothèque de classes Framework (disponible dans tous les langages qui respectent CLS). En fait, int se traduit par Int32 lors de la compilation.

Aussi,

En C #, les mappages longs vers System.Int64, mais dans un langage de programmation différent, long peuvent mapper vers Int16 ou Int32. En fait, C ++ / CLI traite aussi longtemps que Int32.

En fait, la plupart des langages (.NET) ne traiteront même pas longtemps comme un mot-clé et ne compileront pas le code qui l'utilise.

J'ai vu cet auteur, et de nombreux ouvrages standard sur .NET préférant les types FCL (c.-à-d., Int32) aux types primitifs spécifiques au langage (c.-à-d., Int), principalement sur ces problèmes d'interopérabilité.

Praveen
la source
8

Rien. La seule différence entre les types est leur taille (et, par conséquent, la plage de valeurs qu'ils peuvent représenter).

duskwuff -inactif-
la source
8

Une note très importante sur les types 16, 32 et 64:

si vous exécutez cette requête ... Array.IndexOf (new Int16 [] {1,2,3}, 1)

vous êtes supposé obtenir zéro (0) parce que vous demandez ... est 1 dans le tableau de 1, 2 ou 3. si vous obtenez -1 comme réponse, cela signifie que 1 n'est pas dans le tableau de 1, 2 ou 3 .

Eh bien, vérifiez ce que j'ai trouvé: tout ce qui suit devrait vous donner 0 et non -1 (j'ai testé cela dans toutes les versions de framework 2.0, 3.0, 3.5, 4.0)

C #:

Array.IndexOf(new Int16[]{1,2,3}, 1) = -1 (not correct)
Array.IndexOf(new Int32[]{1,2,3}, 1) = 0 (correct)
Array.IndexOf(new Int64[]{1,2,3}, 1) = 0 (correct)

VB.NET:

Array.IndexOf(new Int16(){1,2,3}, 1) = -1 (not correct)
Array.IndexOf(new Int32(){1,2,3}, 1) = 0 (correct)
Array.IndexOf(new Int64(){1,2,3}, 1) = -1 (not correct)

Donc, mon point est, pour les comparaisons Array.IndexOf, faites uniquement confiance à Int32!

tno2007
la source
7
Pour clarifier pourquoi le premier exemple fonctionne de cette façon: le premier littéral 1, le 2 et le 3 sont implicitement transtypés shortpour les adapter au tableau, tandis que le deuxième littéral 1 est laissé comme un ordinaire int. (int)1n'est pas considéré comme égal à (short)1, (short)2, (short)3, donc le résultat est -1.
4
Il y aurait un ajustement similaire disponible pour les versions C #, mais pour info un simple spécificateur de type résout ce problème: Array.IndexOf(new Int16(){1,2,3}, 1S) Array.IndexOf(new Int32(){1,2,3}, 1I) Array.IndexOf(new Int64(){1,2,3}, 1L)tout fonctionne comme prévu.
Mark Hurd
1
Et ceux qui ne fonctionnent pas ont utilisé la Object[],Objectsurcharge. C # élève implicitement le intà un longlorsque cela est nécessaire (et lève également le a shortà un intou long), mais ne sera pas implicitement abaissé, en utilisant la objectsurcharge à la place. Avec Option Strict Onou OffVB n'utilisera la surcharge typée que si les types uniformes sont fournis, sinon il utilise la objectsurcharge.
Mark Hurd
Votre réponse est trompeuse. Le code compare des valeurs de différents types. La conclusion for Array.IndexOf comparisons, only trust Int32!est fausse. Si vous convertissez l' 1argument final en type de tableau correspondant, il fonctionne comme prévu.
Don Cheadle
C'est un comportement très intéressant et inattendu (puisque int pour les longs travaux mais pas pour les int ne fonctionne pas) d'où le vote positif!
sth_Weird
7

EDIT: Ce n'est pas tout à fait vrai pour C #, une balise que j'ai manquée lorsque j'ai répondu à cette question - s'il y a une réponse plus spécifique à C #, veuillez voter pour cela à la place!

Ils représentent tous des nombres entiers de tailles variables.

Cependant, il y a une très très petite différence.

int16, int32 et int64 ont tous une taille fixe .

La taille d'un int dépend de l'architecture pour laquelle vous compilez - la spécification C définit uniquement un int comme plus grand ou égal à un court, bien qu'en pratique c'est la largeur du processeur que vous ciblez, qui est probablement 32 bits mais vous devez savoir que ce pourrait ne pas être.

deanWombourne
la source
1
Cela devrait être la réponse acceptée car c'est la seule qui est réellement correcte
mjs
2
Non, ce n'est pas vrai pour C #. AC # int a toujours une taille de 32 bits. Pour C, oui, vous avez dû faire face à cette complication et vous voyez souvent des macros dans le code C pour gérer les tailles int variables. Voir ecma-international.org/publications/files/ECMA-ST/Ecma-334.pdf page 18.
Ananke
@Ananke Ahh, a raté la balise C #. J'aimerais pouvoir revenir sur les réponses .....
mjs
6
  1. intet int32sont une seule et même chose (entier 32 bits)
  2. int16 est un entier court (2 octets ou 16 bits)
  3. int64 est le type de données long (8 octets ou 64 bits)
Sunil Kumar BM
la source
2
int n'est pas garanti à 32 bits.
mjs
8
@mjs, ce n'est tout simplement pas vrai. En C #, intest un alias pour Int32et est donc toujours garanti à 32 bits.
David Arno
En fait, ce que mjs dit est correct, INT signifie un entier basé sur le système x86 ou x64, donc si votre système est x64, int sera Int64, donc il n'est pas garanti d'être 32 .. Si vous mettez int32 dans un x64 sera toujours int32 .
Yogurtu
5
Non, ce que David Arno dit est correct. Le langage C # définit spécifiquement «int» comme signifiant un entier 32 bits (Int32). D'autres langages (C / C ++, etc.) peuvent ne pas spécifier cela, mais cette question est étiquetée 'C #'.
Theo Brinkman le
@TheoBrinkman Correct, voici la page de Microsoft sur les types numériques intégraux C #: docs.microsoft.com/en-us/dotnet/csharp/language-reference/…
Max Barraclough
5

Ils sont tous les deux synonymes, mais j'ai trouvé la petite différence entre eux,

1) Vous ne pouvez pas utiliser Int32lors de la créationenum 

enum Test : Int32
{ XXX = 1   // gives you compilation error
}

enum Test : int
{ XXX = 1   // Works fine
}

2) Int32relève de la déclaration système. si vous supprimez, using.Systemvous obtiendrez une erreur de compilation, mais pas au cas oùint

this.girish
la source
-8

Int = Int32 -> Type long d'origine

Int16 -> Original int

Int64 -> Un nouveau type de données devient disponible après les systèmes 64 bits

"int" n'est disponible que pour la compatibilité descendante. Nous devrions vraiment utiliser de nouveaux types int pour rendre nos programmes plus précis.

---------------

Une autre chose que j'ai remarquée en cours de route est qu'il n'y a pas de classe nommée Intsimilaire à Int16, Int32 et Int64. Toutes les fonctions utiles comme TryParsepour entier proviennent de Int32.TryParse.

Mahesh
la source