Qu'est-ce que la norme C ++ indique la taille du type long et int?

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

Mais existe-t-il des normes 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 beaucoup de succès, des informations fiables indiquant les dimensions de char, short, int, long, double, float(et d' autres types , je ne pense pas que des) sous différentes architectures et compilateurs.

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 plage requise. Vous pouvez en déduire la taille minimale en octets et la valeur de la CHAR_BITmacro qui définit le nombre de bits dans un octet . Dans toutes les plates-formes, sauf les plus obscures, il s'agit de 8, et il ne peut pas être inférieur à 8. C'est parce qu'il doit être suffisamment grand pour contenir "les unités de code à huit bits de la forme de codage Unicode UTF-8".

Une contrainte supplémentaire charest que sa taille est toujours de 1 octet, ou CHAR_BITbits (d'où le nom). Ceci est indiqué explicitement dans la norme.

La norme C est une référence normative pour la norme C ++, donc même si elle n'énonce pas ces exigences explicitement, C ++ requiert les plages minimales requises par la norme C (page 22), qui sont les mêmes que celles des plages de types de données sur MSDN :

1. signed char: -127 à 127 (notez, pas -128 à 127; ceci accepte les plates-formes de complément à 1 et signe-amplitude)
2. unsigned char: 0 à 255
3. "plain" char: même plage que signed charor unsigned char, définie par l'implémentation
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

Une implémentation C ++ (ou C) peut définir la taille d'un type en octets sizeof(type)à n'importe quelle valeur, tant que

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

Dans l'ensemble, nous avons la garantie que:

• char,, signed charet unsigned charsont au moins 8 bits
• signed short, unsigned short, signed int, Et unsigned intsont au moins 16 bits
• signed longet unsigned longsont au moins 32 bits
• signed long longet unsigned long longsont au moins 64 bits

Aucune garantie n'est faite quant à la taille floatou à l' doubleexception qui doublefournit au moins autant de précision que float.

Les plages spécifiques à l'implémentation peuvent être trouvées dans l'en- <limits.h>tête en C, ou <climits>en C ++ (ou encore mieux, basées std::numeric_limitssur un modèle dans l'en- <limits>tête).

Par exemple, voici comment 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();

Pour les systèmes 32 bits, la norme «de facto» est ILP32 - c'est-à-dire int, longet le pointeur sont tous des quantités 32 bits.

Pour les systèmes 64 bits, la norme Unix principale de facto est LP64 - longet le pointeur est 64 bits (mais int32 bits). La norme Windows 64 bits est LLP64 - long longet pointeur sont 64 bits (mais longet intsont tous les deux 32 bits).

À un moment donné, certains systèmes Unix utilisaient une organisation ILP64.

Aucune de ces normes de facto n'est légiférée par la norme C (ISO / IEC 9899: 1999), mais toutes y sont autorisées.

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

Notez qu'il y avait des machines (Crays) où CHAR_BITétait beaucoup plus grand que 8. Cela signifiait, IIRC, qui sizeof(int)était également 1, car les deux charet intétaient 32 bits.

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

En ce qui concerne tous les autres types intégrés, cela dépend vraiment du compilateur. Voici deux extraits tirés du brouillon de travail actuel de la dernière norme C ++:

Il existe cinq types d'entiers signés standard: char signé, int 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 d'entiers signés standard, il existe un type d'entier standard non signé correspondant (mais différent): char non signé, entier court non signé, entier non signé, entier long non signé et entier long long non signé, chacun occupant la même quantité de stockage et a les mêmes exigences d'alignement.

Si vous le souhaitez, vous pouvez statiquement (au moment de la compilation) affirmer la taille de ces types fondamentaux. Il alertera les gens à penser à porter votre code si la taille des hypothèses change.

Il y a du standard.

La norme C90 exige que

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

La norme C99 exige que

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

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

Voici les tailles de type int (bits) pour les plates-formes 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 que le nom du 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_test garanti à 8 bits, et int16_test garanti à 16 bits, etc.

Si vous avez besoin de types de taille fixe, utilisez des types comme uint32_t (entier non signé 32 bits) défini dans stdint.h . Ils sont spécifiés en C99 .

Mise à jour: C ++ 11 a officiellement introduit les types de TR1 dans la norme:

• long long int
• non signé long long int

Et les types "dimensionnés" de <cstdint>

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

De plus, vous obtenez:

• int_least8_t
• int_least16_t
• int_least32_t
• int_least64_t
• Plus les homologues non signés.

Ces types représentent les plus petits types entiers avec au moins le nombre de bits spécifié. De même, il existe les types entiers "les plus rapides" avec au moins le nombre de bits spécifié:

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

Ce qui signifie "rapide", s'il en est, dépend de la mise en œuvre. Il ne doit pas non plus être le plus rapide à toutes fins.

La norme C ++ le dit comme ceci:

3.9.1, §2:

Il existe cinq types d'entiers signés: "char signé", "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. Les entiers simples ont la taille naturelle suggérée par l'architecture de l'environnement d'exécution (44); les autres types d'entiers signés sont fournis pour répondre à des besoins particuliers.

(44) c'est-à-dire suffisamment grand pour contenir toute valeur dans la plage de INT_MIN et INT_MAX, comme défini dans l'en-tête <climits> .

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

Non, il n'y a pas de norme pour les tailles de caractères. La norme requiert uniquement que:

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

La meilleure chose que vous puissiez faire si vous voulez des variables de tailles fixes est d'utiliser des macros comme celle-ci:

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

Ensuite, vous pouvez utiliser WORD pour définir vos variables. Ce n'est pas que j'aime ça mais c'est le moyen le plus portable .

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, lorsque nous transférons le code sur une machine différente où la taille de long int est en fait de 4, nous pouvons simplement redéfinir la seule occurrence de int.

typedef long int int32;

int32 i;
int32 j;
...

Pour les nombres à virgule flottante, il existe une norme (IEEE754) : les flottants sont 32 bits et les doubles sont 64. Il s'agit d'une norme matérielle, pas d'une norme C ++, de sorte que les compilateurs pourraient théoriquement définir flottant et doubler à une autre taille, mais en pratique, je '' Je n'ai jamais vu une architecture utilisant quelque chose de différent.

Il existe une norme et elle est précisée dans les différents documents de normes (ISO, ANSI et ainsi de suite).

Wikipedia a une grande page expliquant les différents types et le maximum qu'ils peuvent stocker: Entier en informatique.

Cependant, même avec un compilateur C ++ standard, vous pouvez le découvrir relativement 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;
}

La documentation de std :: numeric_limits peut être trouvée sur Roguewave . Il comprend une pléthore 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 transmet la taille, par exemple std :: streamsize.

La réponse de John contient la meilleure description, car celles-ci sont garanties de tenir. Quelle que soit la plateforme sur laquelle vous vous trouvez, il existe une autre bonne page qui explique plus en détail le nombre de bits que chaque type DOIT contenir: les types int , qui sont définis dans la norme.

J'espère que ça aide!

1) Tableau N1 dans l'article " Les problèmes oubliés du développement de programmes 64 bits "

2) " Modèle de données "

Vous pouvez utiliser:

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

datatype = int, long intetc. Vous pourrez voir la taille du type de données que vous saisissez.

Lorsqu'il s'agit de types intégrés pour différentes architectures et différents compilateurs, exécutez simplement le code suivant sur votre architecture avec votre compilateur pour voir ce qu'il génère. 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, c'est pourquoi la sortie est ordonnée en tant que telle:

"Il existe cinq types d'entiers signés standard: char signé, int 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."

#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

Comme mentionné, la taille doit refléter l'architecture actuelle. Vous pouvez faire un tour limits.hsi vous voulez voir comment votre compilateur actuel gère les choses.

Comme d'autres l'ont répondu, les "normes" laissent toutes la plupart des détails comme "implémentation définie" et indiquent seulement que le type "char" est au moins "char_bis" large, et que "char <= short <= int <= long < = long long "(float et double sont à peu près cohérents avec les normes IEEE à virgule flottante, et long double est généralement identique à double - mais peut être plus grand sur les implémentations plus actuelles).

Une partie des raisons pour ne pas avoir de valeurs très spécifiques et exactes est que des langages comme C / C ++ ont été conçus pour être portables sur un grand nombre de plates-formes matérielles - Y compris les systèmes informatiques dans lesquels la taille de mot "char" peut être de 4 bits ou 7 bits, ou même une valeur autre que les ordinateurs "8/16/32/64 bits" auxquels l'utilisateur moyen d'un ordinateur domestique est exposé. (La taille des mots signifie ici combien de bits de large le système fonctionne normalement - Encore une fois, ce n'est pas toujours 8 bits comme les utilisateurs d'ordinateurs personnels peuvent s'y 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 le spécifier; Mais ce n'est généralement pas portable, même entre des compilateurs fabriqués par la société ame mais pour différentes plates-formes. Certaines normes et pratiques (en particulier limits.h et similaires) sont suffisamment courantes pour que la plupart des compilateurs prennent en charge la détermination du type le mieux adapté pour une plage de valeurs spécifique, mais pas le nombre de bits utilisés. (Autrement dit, si vous savez que vous devez conserver des valeurs comprises entre 0 et 127, vous pouvez déterminer que votre compilateur prend en charge un type "int8" de 8 bits qui sera suffisamment grand pour contenir la plage complète souhaitée, mais pas quelque chose comme un type "int7" qui correspondrait exactement à 7 bits.)

Remarque: De nombreux packages source Un * x utilisaient le script "./configure" qui sonderait les capacités du compilateur / système et produirait un Makefile approprié et config.h. Vous pouvez examiner certains de ces scripts pour voir comment ils fonctionnent et comment ils sondent les capacités du comilateur / système et suivre leur exemple.

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

L'idée derrière est très simple: créer une liste contenant les types char, int, short, long, long long (versions signées et non signées) et analyser la liste et en utilisant le modèle numeric_limits sélectionner le type avec la taille donnée.

En incluant cet en-tête, vous avez obtenu 8 types 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é en stdtype :: null_type également déclaré dans cet en-tête.

LE CODE CI-DESSOUS EST DONNÉ SANS GARANTIE, S'IL VOUS PLAÎT DOUBLE LE VERIFIER.
JE SUIS NOUVEAU CHEZ METAPROGRAMMING TOO, N'HÉSITEZ PAS À MODIFIER ET À CORRIGER CE CODE.
Testé avec DevC ++ (donc une version gcc autour de 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;

}

unsigned char bits = sizeof(X) << 3;

où Xest un char, int, longetc .. vous donnera la taille des Xen bits.

De Alex B 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 plage requise. Vous pouvez en déduire la taille minimale en octets 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, c'est 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).

Les plages minimales requises par la norme (page 22) sont:

et plages de types de données sur MSDN:

caractère signé: -127 à 127 (remarque, pas -128 à 127; cela accepte les plates-formes complémentaires de 1) caractère non signé: 0 à 255 caractère "ordinaire": -127 à 127 ou 0 à 255 (dépend de la signature par défaut du caractère) signé court: -32767 à 32767 non signé court: 0 à 65535 signé int: -32767 à 32767 non signé int: 0 à 65535 signé long: -2147483647 à 2147483647 non signé long: 0 à 4294967295 signé long long: -9223372036854775807 à 9223372036854775807 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, tant que

l'expression sizeof (type) * CHAR_BIT évalue le nombre de bits suffisamment pour contenir les plages requises et l'ordre de type est toujours valide (par exemple sizeof (int) <= sizeof (long)). Les plages spécifiques à l'implémentation peuvent être trouvées dans l'en-tête en C, ou en C ++ (ou encore mieux, les modèles std :: numeric_limits dans l'en-tête).

Par exemple, voici comment vous trouverez la plage 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 exact, cependant, vous aviez également 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 toujours 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 normalisation en amont, elle est restée la même. Même les systèmes 64 bits ont tendance à les utiliser et ont des extensions / modifications. Veuillez vous y référer pour plus d'informations:

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

Je remarque que toutes les autres réponses ici se sont concentrées presque exclusivement sur les types intégraux, tandis que le questionneur a également posé des questions sur les virgules flottantes.

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 virgule flottante binaire (ainsi que certains formats BCD, dont je n'ai jamais vu la prise en charge dans les compilateurs C ++):

• Demi-précision (binaire16) - Signification 11 bits, plage d'exposants -14 à 15
• Simple précision (binaire32) - Signification 24 bits, plage d'exposants -126 à 127
• Double précision (binaire64) - signification 53 bits, plage d'exposants -1022 à 1023
• Quadruple précision (binaire128) - Signification 113 bits, plage d'exposants -16382 à 16383

Comment cette mappe sur les types C ++, alors? Généralement, il floatutilise une seule précision; ainsi sizeof(float) = 4. doubleUtilise ensuite la double précision (je crois que c'est la source du nom double), et long doublepeut être double ou quadruple précision (c'est quadruple sur mon système, mais sur les systèmes 32 bits, cela peut être double). Je ne connais aucun compilateur offrant des virgules flottantes de demi-précision.

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

• sizeof(float) = 4
• sizeof(double) = 8
• sizeof(long double) = 8 ou 16

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 celle du compilateur Microsoft: Plages de types de données .

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

Par exemple, Qt fournit qint8 (garanti 8 bits sur toutes les plates-formes prises en charge par Qt), qint16, qint32, qint64, quint8, quint16, quint32, quint64, etc.

Sur une machine 64 bits:

int: 4
long: 8
long long: 8
void*: 8
size_t: 8

Il existe quatre types d'entiers basés sur la taille:

• entier court: 2 octets
• entier long: 4 octets
• entier long long: 8 octets
• entier: dépend du compilateur (16 bits, 32 bits ou 64 bits)