Qu'est-ce que le standard c++ indique la taille de int, long type à être?

je cherche des informations détaillées concernant la taille des types C++ de base. Je sais que cela dépend de l'architecture (16 bits, 32 bits, 64 bits) et le compilateur.

mais y a-t-il des standards pour C++?

J'utilise Visual Studio 2008 sur une architecture 32 bits. Voici ce que j'obtiens:

char  : 1 byte
short : 2 bytes
int   : 4 bytes
long  : 4 bytes
float : 4 bytes
double: 8 bytes

j'ai essayé de trouver, sans succès, d'informations fiables indiquant les tailles de char , short , int , long , double , float (et d'autres types auxquels je n'avais pas pensé) sous différentes architectures et compilateurs.

635
demandé sur Jonathan Leffler 2009-02-26 10:59:23

24 réponses

la norme C++ ne spécifie pas la taille des types intégraux en octets, mais elle spécifie les plages minimales qu'ils doivent pouvoir contenir. Vous pouvez déduire la taille minimale en bits de la gamme requise. Vous pouvez déduire la taille minimale en octets à partir de cela et la valeur de la macro CHAR_BIT qui définit le nombre de bits dans un octet (dans toutes les plates-formes sauf les plus obscures, il est de 8, et il ne peut pas être inférieur à 8).

Une contrainte supplémentaire pour char est que sa taille est toujours de 1 octet, ou CHAR_BIT bits (d'où le nom).

Minimum des plages requis par la norme (page 22):

et plages de types de données sur MSDN :

  1. signed char : -127 à 127 (à noter, pas de -128 à 127; ce peut accueillir 1-compléter et signer-et-l'ampleur des plates-formes)
  2. unsigned char : 0 à 255
  3. "plain" char : même gamme que signed char ou unsigned char , implémentation-defined
  4. signed short : -32767 à 32767
  5. unsigned short : 0 à 65535
  6. signed int : -32767 à 32767
  7. unsigned int : 0 à 65535
  8. signed long : -2147483647 à 2147483647
  9. unsigned long : 0 à 4294967295
  10. signed long long : -9223372036854775807 à 9223372036854775807
  11. unsigned long long : 0 à 18446744073709551615

en C++ (ou C) de la mise en œuvre peut définir la taille d'un type en octets sizeof(type) à une valeur quelconque, tant que

  1. l'expression sizeof(type) * CHAR_BIT évalue à un nombre de bits suffisamment élevé pour contenir les plages requises, et
  2. l'ordre du type est toujours valide (par exemple sizeof(int) <= sizeof(long) ).

les gammes spécifiques à la mise en œuvre peuvent être trouvées dans <limits.h> en-tête en C, ou <climits> en C++ (ou encore mieux, std::numeric_limits dans <limits> en-tête).

par exemple, c'est ainsi que vous trouverez la portée maximale pour int :

C:

#include <limits.h>
const int min_int = INT_MIN;
const int max_int = INT_MAX;

C++ :

#include <limits>
const int min_int = std::numeric_limits<int>::min();
const int max_int = std::numeric_limits<int>::max();
637
répondu Alex B 2017-05-23 12:02:43

pour les systèmes 32 bits, le standard "de facto" est ILP32 - c'est-à-dire int , long et pointeur sont tous des quantités 32 bits.

pour les systèmes 64 bits, la norme Unix primaire "de facto" est LP64 - long et le pointeur sont 64 bits (mais int est 32 bits). Le standard de Windows 64 bits est LLP64 - long long et le pointeur sont 64 bits (mais long et int sont tous les deux 32 bits).

à un moment, certains Unix les systèmes utilisaient une organisation ILP64.

aucune de ces normes de facto n'est régie par la norme C (ISO/IEC 9899:1999), mais toutes sont autorisées par celle-ci.

et, par définition, sizeof(char) est 1 , malgré le test du script de configuration Perl.

notez qu'il y avait des machines (Crays) où CHAR_BIT était beaucoup plus grand que 8. Cela signifie, IIRC, que sizeof(int) était aussi 1, parce que les deux char et int étaient 32 bits.

212
répondu Jonathan Leffler 2014-10-03 08:17:37

dans la pratique, il n'y a rien de tel. Souvent, vous pouvez vous attendre à ce que std::size_t représente la taille entière non signée sur l'architecture courante. c'est à dire 16 bits, 32 bits ou 64 bits, mais il n'est pas toujours le cas comme l'a souligné dans les commentaires de cette réponse.

autant que tous les autres types intégrés vont, cela dépend vraiment du compilateur. Voici deux extraits tirés du projet de travail actuel de la dernière norme c++:

Il existe cinq types d'entiers signés standard : char signé, court int, long int et long long int. Dans cette liste, chaque type fournit au moins autant de stockage que ceux qui le précèdent dans la liste.

pour chacun des types entiers signés standard, il existe un type entier standard correspondant (mais différent): non signé char, non signé short int, non signé int, non signé long int, et non signé long int, dont chacun occupe la même quantité de stockage et a les mêmes exigences alignement.

si vous voulez vous pouvez statiquement (compiler-time) affirmer la taille de ces types fondamentaux. Il avertira les gens de penser à porter votre code si la taille des hypothèses changent.

83
répondu John Leidegren 2018-05-15 11:37:29

il y a la norme.

C90 norme exige que

sizeof(short) <= sizeof(int) <= sizeof(long)

standard C99 exige que

sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long)

Voici les spécifications C99 . La page 22 détaille les tailles des différents types intégraux.

Voici les tailles de type int (bits) pour les plateformes Windows:

Type           C99 Minimum     Windows 32bit
char           8               8
short          16              16
int            16              32
long           32              32
long long      64              64

si vous êtes concerné par la portabilité, ou si vous voulez le nom le type reflète la taille, vous pouvez regarder l'en-tête <inttypes.h> , où les macros suivantes sont disponibles:

int8_t
int16_t
int32_t
int64_t

int8_t est garantie 8 bits, et int16_t , est garanti à 16 bits, etc.

79
répondu yinyueyouge 2018-01-19 18:11:34

si vous avez besoin de types de taille fixe, utilisez des types comme uint32_t (unsigned integer 32 bits) défini dans stdint.h . Ils sont spécifiés dans C99 .

38
répondu Ben 2016-05-06 17:14:55

mise à Jour: C++11 introduit les types de TR1 officiellement dans la norme:

  • long long int
  • non signé long long int

et les types" calibrés "de <cstdint>

  • int8_t
  • int16_t
  • int32_t
  • int64_t
  • (et les équivalents non signés).

Plus vous obtenez:

  • int_least8_t
  • int_least16_t
  • int_least32_t
  • int_least64_t
  • Plus les contreparties non signées.

ces types représentent les plus petits nombres entiers avec au moins le nombre spécifié de bits. De même il y a les types d'entiers les plus "rapides" avec au moins le nombre spécifié de bits:

  • int_fast8_t
  • int_fast16_t
  • int_fast32_t
  • int_fast64_t
  • Plus les versions non signées.

ce que "fast" signifie, s'il y a lieu, est à la hauteur de la mise en œuvre. Il n'a pas besoin d'être le plus rapide pour tous les buts.

32
répondu Brian Neal 2014-09-18 03:04:41

Le C++ Standard , il dit comme ça:

3.9.1, §2:

il y a cinq types entiers signés : "signed char", "short int", " int", "long int" et "long long int". Dans cette liste, chaque type fournit au moins autant de stockage que ceux qui le précèdent dans la liste. Plaine ints ont l' taille naturelle suggérée par le l'architecture de l'exécution de l'environnement (44); l'autre signé entier les types sont fournis pour répondre aux des besoins spéciaux.

(44) c'est-à-dire, assez grand pour contenir n'importe quelle valeur dans la gamme de INT_MIN et INT_MAX, tel que défini dans l'en-tête <climits> .

La conclusion: Ça dépend de l'architecture sur laquelle vous travaillez. Toute autre hypothèse est fausse.

17
répondu Jérôme Radix 2016-05-06 17:17:25

Non, il n'y a pas de norme pour les tailles de type. La norme exige seulement que:

sizeof(short int) <= sizeof(int) <= sizeof(long int)

La meilleure chose que vous pouvez faire si vous voulez variables d'une taille fixe est d'utiliser des macros comme ceci:

#ifdef SYSTEM_X
  #define WORD int
#else
  #define WORD long int
#endif

alors vous pouvez utiliser WORD pour définir vos variables. Ce n'est pas que j'aime ça, mais c'est la façon la plus portable .

12
répondu Emiliano 2009-02-26 08:07:09

nous sommes autorisés à définir un synonyme pour le type afin que nous puissions créer notre propre"standard".

sur une machine dans laquelle sizeof (int) == 4, on peut définir:

typedef int int32;

int32 i;
int32 j;
...

ainsi quand nous transférons le code à une machine différente où en fait la taille de long int est 4, nous pouvons juste redéfinir la seule occurrence de int.

typedef long int int32;

int32 i;
int32 j;
...
9
répondu milan-j 2015-07-14 07:06:13

pour les nombres à virgule flottante il y a une norme (IEEE754) : flotteurs sont de 32 bits et doubles sont de 64. C'est un standard matériel, pas un standard C++, donc les compilateurs pourraient théoriquement définir float et double à une autre taille, mais en pratique, je n'ai jamais vu une architecture qui utilise quelque chose de différent.

8
répondu Crashworks 2009-02-26 08:49:36

il existe une norme et elle est spécifiée dans les différents documents de normes (ISO, ANSI et autres).

Wikipedia a une grande page expliquant les différents types et le max qu'ils peuvent stocker: Entier dans l'Informatique.

cependant, même avec un compilateur C++ standard, vous pouvez le découvrir assez facilement en utilisant l'extrait de code suivant:

#include <iostream>
#include <limits>


int main() {
    // Change the template parameter to the various different types.
    std::cout << std::numeric_limits<int>::max() << std::endl;
}

Documentation pour std:: numeric_limits peut être trouvé à Roguewave . Il comprend une multitude d'autres commandes que vous pouvez appeler pour connaître les différentes limites. Cela peut être utilisé avec n'importe quel type arbitraire qui communique la taille, par exemple std::streamsize.

la réponse de John contient la meilleure description, comme ceux-ci sont garantis pour tenir. Peu importe quelle plate-forme vous êtes sur, il y a une autre bonne page qui va dans plus de détails quant au nombre de bits chaque type doit contient: types int , qui sont définis dans la norme.

j'espère que cela aidera!

7
répondu X-Istence 2009-02-26 08:13:26
7
répondu 2009-02-26 20:31:18

vous pouvez utiliser:

cout << "size of datatype = " << sizeof(datatype) << endl;

datatype = int , long int etc. Vous pourrez voir la taille de n'importe quel type de données que vous taperez.

7
répondu Population Xplosive 2014-05-16 05:45:41

quand il s'agit de types intégrés pour différentes architectures et différents compilateurs il suffit d'exécuter le code suivant sur votre architecture avec votre compilateur pour voir ce qu'il produit. Ci-dessous montre ma sortie Ubuntu 13.04 (Raring Ringtail) 64 bits g++4.7.3. Veuillez également noter ce qui a été répondu ci-dessous qui est la raison pour laquelle la sortie est ordonnée comme telle:

" il y a cinq types d'entiers signés standard: char signé, court int, int, long int, et long long int. Dans cette liste, chaque type fournit au moins autant de stockage que ceux qui le précèdent dans la liste."

#include <iostream>

int main ( int argc, char * argv[] )
{
  std::cout<< "size of char: " << sizeof (char) << std::endl;
  std::cout<< "size of short: " << sizeof (short) << std::endl;
  std::cout<< "size of int: " << sizeof (int) << std::endl;
  std::cout<< "size of long: " << sizeof (long) << std::endl;
  std::cout<< "size of long long: " << sizeof (long long) << std::endl;

  std::cout<< "size of float: " << sizeof (float) << std::endl;
  std::cout<< "size of double: " << sizeof (double) << std::endl;

  std::cout<< "size of pointer: " << sizeof (int *) << std::endl;
}


size of char: 1
size of short: 2
size of int: 4
size of long: 8
size of long long: 8
size of float: 4
size of double: 8
size of pointer: 8
6
répondu bjackfly 2016-05-06 17:24:41

comme mentionné la taille doit refléter l'architecture actuelle. Vous pouvez prendre un pic dans limits.h si vous voulez voir comment votre compilateur actuel gère les choses.

4
répondu John T 2013-07-24 10:18:46

comme d'autres ont répondu, les" standards "laissent tous la plupart des détails comme" implementation defined "et indiquent seulement que le type" char "est au moins" char_bis "large, et que" char <= short <= int <= long <= long long long " (flottant et double sont assez conformes aux standards IEEE floating point, et long double est typiquement identique à double--mais peut être plus grand sur les implémentations plus courantes).

une partie des raisons de ne pas avoir très spécifique et exacte les valeurs sont parce que les langages comme C/C++ ont été conçus pour être portables à un grand nombre de plates-formes matérielles--y compris les systèmes informatiques dans lesquels la taille du mot "char" peut être 4 bits ou 7 bits, ou même une valeur autre que "8-/16-/32-/64-l'utilisateur moyen d'un ordinateur à domicile est exposé à des micro-ordinateurs. (La taille de mot ici signifie Combien de bits le système fonctionne normalement sur--Encore une fois, ce n'est pas toujours 8-bits comme les utilisateurs d'ordinateur à la maison peuvent s'attendre.)

Si vous avez vraiment besoin d'un objet (dans le sens d'une série de bits représentant une valeur intégrale) d'un nombre spécifique de bits, la plupart des compilateurs ont une méthode pour spécifier cela; mais ce n'est généralement pas portable, même entre compilateurs faits par la société ame, mais pour différentes plateformes. Certaines normes et pratiques (notamment les limites.h et similaires) sont assez communs pour que la plupart des compilateurs puissent déterminer le type le mieux adapté à une plage de valeurs spécifique, mais pas le nombre de bits utilisés. (Qui est, si vous sachez que vous devez maintenir les valeurs entre 0 et 127, vous pouvez déterminer que votre compilateur supporte un type "int8" de 8 bits qui sera assez grand pour contenir la gamme complète désirée, mais pas quelque chose comme un type "int7" qui serait une correspondance exacte pour 7 bits.)

Note: de nombreux paquets sources Un*x utilisés"./ configure" script qui sondera les capacités du compilateur/système et affichera un Makefile et une configuration appropriés.h. Vous pourriez examiner certains de ces scripts pour voir comment ils le travail et la façon dont ils sondent les capacités du comiler/système, et suivent leur exemple.

2
répondu C. M. 2013-05-27 07:04:36

si vous êtes intéressé par une solution pure C++, j'ai utilisé des modèles et seulement du code standard C++ pour définir les types au moment de la compilation en fonction de leur taille de bits. Cela rend la solution portable à travers les compilateurs.

L'idée derrière est très simple: créer une liste contenant les types char, int, short, long, long long (version signée et non signée) et le scanner la liste et par l'utilisation du modèle numeric_limits choisir le type avec la taille donnée.

Y compris cet en-tête, vous avez 8 type stdtype::int8, stdtype::int16, stdtype::int32, stdtype::int64, stdtype::uint8, stdtype::uint16, stdtype::uint32, stdtype::uint64.

si un type ne peut pas être représenté, il sera évalué à stdtype::null_type également déclaré dans cet en-tête.

LE CODE CI-DESSOUS EST FOURNI SANS GARANTIE, VEUILLEZ LE VÉRIFIER DEUX FOIS.

JE SUIS NOUVEAU À METAPROGRAMMING AUSSI, N'HÉSITEZ PAS À ÉDITER ET CORRIGER CE CODE.

Testé avec DevC++ (donc une version gcc vers 3.5)

#include <limits>

namespace stdtype
{
    using namespace std;


    /*
     * THIS IS THE CLASS USED TO SEMANTICALLY SPECIFY A NULL TYPE.
     * YOU CAN USE WHATEVER YOU WANT AND EVEN DRIVE A COMPILE ERROR IF IT IS 
     * DECLARED/USED.
     *
     * PLEASE NOTE that C++ std define sizeof of an empty class to be 1.
     */
    class null_type{};

    /*
     *  Template for creating lists of types
     *
     *  T is type to hold
     *  S is the next type_list<T,S> type
     *
     *  Example:
     *   Creating a list with type int and char: 
     *      typedef type_list<int, type_list<char> > test;
     *      test::value         //int
     *      test::next::value   //char
     */
    template <typename T, typename S> struct type_list
    {
        typedef T value;
        typedef S next;         

    };




    /*
     * Declaration of template struct for selecting a type from the list
     */
    template <typename list, int b, int ctl> struct select_type;


    /*
     * Find a type with specified "b" bit in list "list"
     *
     * 
     */
    template <typename list, int b> struct find_type
    {   
        private:
            //Handy name for the type at the head of the list
            typedef typename list::value cur_type;

            //Number of bits of the type at the head
            //CHANGE THIS (compile time) exp TO USE ANOTHER TYPE LEN COMPUTING
            enum {cur_type_bits = numeric_limits<cur_type>::digits};

        public:
            //Select the type at the head if b == cur_type_bits else
            //select_type call find_type with list::next
            typedef  typename select_type<list, b, cur_type_bits>::type type;
    };

    /*
     * This is the specialization for empty list, return the null_type
     * OVVERRIDE this struct to ADD CUSTOM BEHAVIOR for the TYPE NOT FOUND case
     * (ie search for type with 17 bits on common archs)
     */
    template <int b> struct find_type<null_type, b>
    {   
        typedef null_type type;

    };


    /*
     * Primary template for selecting the type at the head of the list if
     * it matches the requested bits (b == ctl)
     *
     * If b == ctl the partial specified templated is evaluated so here we have
     * b != ctl. We call find_type on the next element of the list
     */
    template <typename list, int b, int ctl> struct select_type
    {   
            typedef  typename find_type<typename list::next, b>::type type; 
    };

    /*
     * This partial specified templated is used to select top type of a list
     * it is called by find_type with the list of value (consumed at each call)
     * the bits requested (b) and the current type (top type) length in bits
     *
     * We specialice the b == ctl case
     */
    template <typename list, int b> struct select_type<list, b, b>
    {
            typedef typename list::value type;
    };


    /*
     * These are the types list, to avoid possible ambiguity (some weird archs)
     * we kept signed and unsigned separated
     */

    #define UNSIGNED_TYPES type_list<unsigned char,         \
        type_list<unsigned short,                           \
        type_list<unsigned int,                             \
        type_list<unsigned long,                            \
        type_list<unsigned long long, null_type> > > > >

    #define SIGNED_TYPES type_list<signed char,         \
        type_list<signed short,                         \
        type_list<signed int,                           \
        type_list<signed long,                          \
        type_list<signed long long, null_type> > > > >



    /*
     * These are acutally typedef used in programs.
     * 
     * Nomenclature is [u]intN where u if present means unsigned, N is the 
     * number of bits in the integer
     *
     * find_type is used simply by giving first a type_list then the number of 
     * bits to search for.
     *
     * NB. Each type in the type list must had specified the template 
     * numeric_limits as it is used to compute the type len in (binary) digit.
     */
    typedef find_type<UNSIGNED_TYPES, 8>::type  uint8;
    typedef find_type<UNSIGNED_TYPES, 16>::type uint16;
    typedef find_type<UNSIGNED_TYPES, 32>::type uint32;
    typedef find_type<UNSIGNED_TYPES, 64>::type uint64;

    typedef find_type<SIGNED_TYPES, 7>::type    int8;
    typedef find_type<SIGNED_TYPES, 15>::type   int16;
    typedef find_type<SIGNED_TYPES, 31>::type   int32;
    typedef find_type<SIGNED_TYPES, 63>::type   int64;

}
1
répondu user781847 2012-10-26 17:43:10
unsigned char bits = sizeof(X) << 3;

X est char , int , long etc.. vous donnera la taille de X en bits.

0
répondu user3154672 2014-01-02 18:41:56

D'Alex B La norme C++ ne spécifie pas la taille des types intégraux en octets, mais elle spécifie les intervalles minimums qu'ils doivent pouvoir contenir. Vous pouvez déduire la taille minimale en bits de la gamme requise. Vous pouvez déduire la taille minimale en octets à partir de cela et de la valeur de la macro CHAR_BIT qui définit le nombre de bits dans un octet (dans toutes les plates-formes sauf les plus obscures c'est 8, et ça ne peut pas être moins de 8).

une contrainte supplémentaire pour char est que sa taille est toujours 1 octet, ou bits CHAR_BIT (d'où le nom).

les plages minimales exigées par la norme (page 22) sont les suivantes:

et plages de types de données sur MSDN:

char signé: -127 à 127 (note, pas -128 à 127; cela s'applique aux plateformes 1's-complement) unsigned char: de 0 à 255 char "simple": -127 à 127 ou 0 à 255 (dépend de la signification par défaut)) court métrage signé: -32767 à 32767 court-métrage non signé: 0 à 65535 signé int: -32767 à Trente deux mille sept cent soixante sept unsigned int: 0 à 65535 signé long: -2147483647 à 2147483647 non signé long: 0 à 4294967295 signé long long: -9223372036854775807 à 9223372036854775807 long long non signé: 0 à 18446744073709551615 Une implémentation C++ (ou C) peut définir la taille d'un type en octets sizeof(type) à n'importe quelle valeur, aussi longtemps que

l'expression sizeof (type) * CHAR_BIT est évaluée au nombre de bits suffisant pour contenir les plages requises, et l'ordre du type est toujours valide (par exemple sizeof(int) <= sizeof(long)). Les plages spécifiques à l'implémentation peuvent être trouvées dans header en C, ou en C++ (ou encore mieux, templated std::numeric_limits dans header).

par exemple, c'est ainsi que vous trouverez la portée maximale pour int:

C:

#include <limits.h>
const int min_int = INT_MIN;
const int max_int = INT_MAX;

C++:

#include <limits>
const int min_int = std::numeric_limits<int>::min();
const int max_int = std::numeric_limits<int>::max();

C'est correct, cependant, vous avez aussi raison de dire que: char : 1 octet Court : 2 octets int: 4 octets long : 4 octets float: 4 octets double: 8 octets

parce que les architectures 32 bits sont encore les architectures par défaut et les plus utilisées, et elles ont conservé ces tailles standard depuis les jours pré-32 bits où la mémoire était moins disponible, et pour la compatibilité et la standardisation à rebours, il est resté le même. Même les systèmes 64 bits ont tendance à les utiliser et ont des extensions/modifications. S'il vous plaît référence à ceci pour plus d'informations:

http://en.cppreference.com/w/cpp/language/types

0
répondu JCoder 2015-02-23 19:05:49

je remarque que toutes les autres réponses ici ont porté presque exclusivement sur les types intégraux, tandis que l'auteur de la question s'est également interrogé sur les flottants-points.

Je ne pense pas que la norme c++ l'exige, mais les compilateurs pour les plates-formes les plus courantes de nos jours suivent généralement la norme IEEE754 pour leurs nombres à virgule flottante. Cette norme spécifie quatre types de points flottants binaires (ainsi que certains formats BCD, pour lesquels je n'ai jamais vu de support en C++) les compilateurs):

  • la Moitié de précision (binary16) - 11 bits significande, plage d'exposants -14 15
  • Simple précision (binary32) - 24 bits significande, plage d'exposants -126 à 127
  • Double précision (binary64) - 53-bit significande, plage d'exposants -1022 à 1023
  • quadruple précision (binary128) - significatif à 113 bits, exposant plage -16382 à 16383

Comment est-ce que cette correspondance avec les types C++, alors? En général, le float utilise une seule précision; ainsi, sizeof(float) = 4 . Puis double utilise la double précision (je crois que c'est la source du nom double ), et long double peut être soit double ou quadruple précision (c'est quadruple sur mon système, mais sur les systèmes 32 bits il peut être double). Je ne connais aucun compilateur qui offre des points flottants de demi-précision.

En résumé, c'est l'habituel:

  • sizeof(float) = 4
  • sizeof(double) = 8
  • sizeof(long double) = 8 ou 16
0
répondu celticminstrel 2015-07-01 13:56:32

comme vous l'avez mentionné - cela dépend en grande partie du compilateur et de la plate-forme. Pour cela, consultez la norme ANSI, http://home.att.net/~jackklein/c/inttypes.html

Voici celui du compilateur Microsoft: " Data Type Ranges ".

0
répondu atVelu 2016-05-06 17:13:43

vous pouvez utiliser des variables fournies par les bibliothèques telles que OpenGL , Qt , etc.

par exemple, Qt fournit qint8 (garanti à 8 bits sur toutes les plateformes supportées par Qt), qint16, qint32, qint64, quint8, quint16, quint32, quint64, etc.

-1
répondu Lawand 2016-05-06 17:16:43

sur une machine 64 bits:

int: 4
long: 8
long long: 8
void*: 8
size_t: 8
-7
répondu user2826084 2016-05-06 17:25:00

il y a quatre types d'entiers basés sur la taille:

  • nombre entier Court: 2 octets
  • long entier: 4 byte
  • long entier long: 8 octets
  • integer: dépend du compilateur (16 bits, 32 bits ou 64 bits)
-8
répondu ricky 2016-05-06 17:20:35