What does the C standard state the size of int long type to be

Question

I m looking for detailed information regarding the size of basic C   types  I know that it depends on the architecture  16 bits  32 bits  64 bits  and the compiler   But are there any standards for C     I m using Visual Studio 2008 on a 32-bit architecture  Here is what I get   char    1 byte short   2 bytes int     4 bytes long    4 bytes float   4 bytes double  8 bytes   I tried to find  without much success  reliable information stating the sizes of char  short  int  long  double  float  and other types I didn t think of  under different architectures and compilers

User · Answer

As mentioned the size should reflect the current architecture  You could take a peak around in limits h if you want to see how your current compiler is handling things

User · Answer

On a 64-bit machine    int  4 long  8 long long  8 void   8 size t  8

User · Answer

There is standard    C90 standard requires that  sizeof short   lt   sizeof int   lt   sizeof long    C99 standard requires that  sizeof short   lt   sizeof int   lt   sizeof long   lt   sizeof long long    Here is the C99 specifications  Page 22 details sizes of different integral types    Here is the int type sizes  bits  for Windows platforms   Type           C99 Minimum     Windows 32bit char           8               8 short          16              16 int            16              32 long           32              32 long long      64              64   If you are concerned with portability  or you want the name of the type reflects the size  you can look at the header  lt inttypes h gt   where the following macros are available   int8 t int16 t int32 t int64 t   int8 t is guaranteed to be 8 bits  and int16 t is guaranteed to be 16 bits  etc

User · Answer

As others have answered  the  standards  all leave most of the details as  implementation defined  and only state that type  char  is at leat  char bis  wide  and that  char  lt   short  lt   int  lt   long  lt   long long   float and double are pretty much consistent with the IEEE floating point standards  and long double is typically same as double--but may be larger on more current implementations    Part of the reasons for not having very specific and exact values is because languages like C C   were designed to be portable to a large number of hardware platforms--Including computer systems in which the  char  word-size may be 4-bits or 7-bits  or even some value other than the  8- 16- 32- 64-bit  computers the average home computer user is exposed to   Word-size here meaning how many bits wide the system normally operates on--Again  it s not always 8-bits as home computer users may expect    If you really need a object  in the sense of a series of bits representing an integral value  of a specific number of bits  most compilers have some method of specifying that  But it s generally not portable  even between compilers made by the ame company but for different platforms  Some standards and practices  especially limits h and the like  are common enough that most compilers will have support for determining at the best-fit type for a specific range of values  but not the number of bits used   That is  if you know you need to hold values between 0 and 127  you can determine that your compiler supports an  int8  type of 8-bits which will be large enought to hold the full range desired  but not something like an  int7  type which would be an exact match for 7-bits    Note  Many Un x source packages used    configure  script which will probe the compiler system s capabilities and output a suitable Makefile and config h  You might examine some of these scripts to see how they work and how they probe the comiler system capabilities  and follow their lead

User · Answer

Nope  there is no standard for type sizes  Standard only requires that   sizeof short int   lt   sizeof int   lt   sizeof long int    The best thing you can do if you want variables of a fixed sizes is to use macros like this    ifdef SYSTEM X    define WORD int  else    define WORD long int  endif   Then you can use WORD to define your variables  It s not that I like this but it s the most portable way

User · Answer

For floating point numbers there is a standard  IEEE754   floats are 32 bit and doubles are 64  This is a hardware standard  not a C   standard  so compilers could theoretically define float and double to some other size  but in practice I ve never seen an architecture that used anything different

User · Answer

From Alex B The C   standard does not specify the size of integral types in bytes  but it specifies minimum ranges they must be able to hold  You can infer minimum size in bits from the required range  You can infer minimum size in bytes from that and the value of the CHAR BIT macro that defines the number of bits in a byte  in all but the most obscure platforms it s 8  and it can t be less than 8    One additional constraint for char is that its size is always 1 byte  or CHAR BIT bits  hence the name    Minimum ranges required by the standard  page 22  are   and Data Type Ranges on MSDN   signed char  -127 to 127  note  not -128 to 127  this accommodates 1 s-complement platforms  unsigned char  0 to 255  plain  char  -127 to 127 or 0 to 255  depends on default char signedness  signed short  -32767 to 32767 unsigned short  0 to 65535 signed int  -32767 to 32767 unsigned int  0 to 65535 signed long  -2147483647 to 2147483647 unsigned long  0 to 4294967295 signed long long  -9223372036854775807 to 9223372036854775807 unsigned long long  0 to 18446744073709551615 A C    or C  implementation can define the size of a type in bytes sizeof type  to any value  as long as  the expression sizeof type    CHAR BIT evaluates to the number of bits enough to contain required ranges  and the ordering of type is still valid  e g  sizeof int   lt   sizeof long    The actual implementation-specific ranges can be found in  header in C  or  in C    or even better  templated std  numeric limits in  header    For example  this is how you will find maximum range for int   C    include  lt limits h gt  const int min int   INT MIN  const int max int   INT MAX    C      include  lt limits gt  const int min int   std  numeric limits lt int gt   min    const int max int   std  numeric limits lt int gt   max      This is correct  however  you were also right in saying that  char     1 byte short    2 bytes int      4 bytes long     4 bytes float    4 bytes double   8 bytes  Because 32 bit architectures are still the default and most used  and they have kept these standard sizes since the pre-32 bit days when memory was less available  and for backwards compatibility and standardization it remained the same  Even 64 bit systems tend to use these and have extentions modifications  Please reference this for more information   http   en cppreference com w cpp language types

User · Answer

If you need fixed size types  use types like uint32 t  unsigned integer 32 bits  defined in stdint h  They are specified in C99

User · Answer

For 32-bit systems  the  de facto  standard is ILP32     that is  int  long and pointer are all 32-bit quantities   For 64-bit systems  the primary Unix  de facto  standard is LP64     long and pointer are 64-bit  but int is 32-bit    The Windows 64-bit standard is LLP64     long long and pointer are 64-bit  but long and int are both 32-bit    At one time  some Unix systems used an ILP64 organization   None of these de facto standards is legislated by the C standard  ISO IEC 9899 1999   but all are permitted by it   And  by definition  sizeof char  is 1  notwithstanding the test in the Perl configure script   Note that there were machines  Crays  where CHAR BIT was much larger than 8   That meant  IIRC  that sizeof int  was also 1  because both char and int were 32-bit

User · Answer

In practice there s no such thing  Often you can expect std  size t to  represent the unsigned native integer size on current architecture  i e  16-bit  32-bit or 64-bit but it isn t always the case as pointed out in the comments to this answer  As far as all the other built-in types go  it really depends on the compiler  Here s two excerpts taken from the current working draft of the latest C   standard   There are five standard signed integer types   signed char  short int  int  long int  and long long int  In this list  each type provides at least as much storage as those preceding it in the list  For each of the standard signed integer types  there exists a corresponding  but different  standard unsigned integer type  unsigned char  unsigned short int  unsigned int  unsigned long int  and unsigned long long int  each of which occupies the same amount of storage and has the same alignment requirements   If you want to you can statically  compile-time  assert the sizeof these fundamental types  It will alert people to think about porting your code if the sizeof assumptions change

User · Answer

There are four types of integers based on size    short integer  2 byte long integer  4 byte long long integer  8 byte integer  depends upon the compiler  16 bit  32 bit  or 64 bit

User · Answer

You can use variables provided by libraries such as OpenGL  Qt  etc   For example  Qt provides qint8  guaranteed to be 8-bit on all platforms supported by Qt   qint16  qint32  qint64  quint8  quint16  quint32  quint64  etc

User · Answer

If you are interested in a pure C   solution  I made use of templates and only C   standard code to define types at compile time based on their bit size   This make the solution portable across compilers   The idea behind is very simple  Create a list containing types char  int  short  long  long long  signed and unsigned versions  and the scan the list and by the use of numeric limits template select the type with given size   Including this header you got 8 type stdtype  int8  stdtype  int16  stdtype  int32  stdtype  int64  stdtype  uint8  stdtype  uint16  stdtype  uint32  stdtype  uint64   If some type cannot be represented it will be evaluated to stdtype  null type also declared in that header   THE CODE BELOW IS GIVEN WITHOUT WARRANTY  PLEASE DOUBLE CHECK IT  I M NEW AT METAPROGRAMMING TOO  FEEL FREE TO EDIT AND CORRECT THIS CODE  Tested with DevC    so a gcc version around 3 5    include  lt limits gt   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 lt T S gt  type                Example           Creating a list with type int and char               typedef type list lt int  type list lt char gt   gt  test              test  value           int             test  next  value     char             template  lt typename T  typename S gt  struct type list               typedef T value          typedef S next                                     Declaration of template struct for selecting a type from the list             template  lt typename list  int b  int ctl gt  struct select type                  Find a type with specified  b  bit in list  list                             template  lt typename list  int b gt  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 lt cur type gt   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 lt list  b  cur type bits gt   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  lt int b gt  struct find type lt null type  b gt                   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  lt typename list  int b  int ctl gt  struct select type                      typedef  typename find type lt typename list  next  b gt   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  lt typename list  int b gt  struct select type lt list  b  b gt                    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 lt unsigned char                    type list lt unsigned short                                      type list lt unsigned int                                        type list lt unsigned long                                       type list lt unsigned long long  null type gt   gt   gt   gt   gt        define SIGNED TYPES type list lt signed char                    type list lt signed short                                    type list lt signed int                                      type list lt signed long                                     type list lt signed long long  null type gt   gt   gt   gt   gt                   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 lt UNSIGNED TYPES  8 gt   type  uint8      typedef find type lt UNSIGNED TYPES  16 gt   type uint16      typedef find type lt UNSIGNED TYPES  32 gt   type uint32      typedef find type lt UNSIGNED TYPES  64 gt   type uint64       typedef find type lt SIGNED TYPES  7 gt   type    int8      typedef find type lt SIGNED TYPES  15 gt   type   int16      typedef find type lt SIGNED TYPES  31 gt   type   int32      typedef find type lt SIGNED TYPES  63 gt   type   int64

User · Answer

As you mentioned - it largely depends upon the compiler and the platform  For this  check the ANSI standard  http   home att net  jackklein c inttypes html  Here is the one for the Microsoft compiler  Data Type Ranges

User · Answer

There is a standard and it is specified in the various standards documents  ISO  ANSI and whatnot    Wikipedia has a great page explaining the various types and the max they may store  Integer in Computer Science   However even with a standard C   compiler you can find out relatively easily using the following code snippet    include  lt iostream gt   include  lt limits gt    int main            Change the template parameter to the various different types      std  cout  lt  lt  std  numeric limits lt int gt   max    lt  lt  std  endl      Documentation for std  numeric limits can be found at Roguewave  It includes a plethora of other commands you can call to find out the various limits  This can be used with any arbitrary type that conveys size  for example std  streamsize   John s answer contains the best description  as those are guaranteed to hold  No matter what platform you are on  there is another good page that goes into more detail as to how many bits each type MUST contain  int types  which are defined in the standard   I hope this helps

User · Answer

The C   Standard says it like this   3 9 1    2      There are five signed integer types      signed char    short int    int      long int   and  long long int   In   this list  each type provides at least   as much storage as those preceding it   in the list  Plain ints have the   natural size suggested by the   architecture of the execution   environment  44   the other signed   integer types are provided to meet   special needs        44  that is  large enough to contain   any value in the range of INT MIN and   INT MAX  as defined in the header    lt climits gt     The conclusion  It depends on which architecture you re working on  Any other assumption is false

User · Answer

You can use   cout  lt  lt   size of datatype      lt  lt  sizeof datatype   lt  lt  endl    datatype   int  long int etc  You will be able to see the size for whichever datatype you type

User · Answer

We are allowed to define a synonym for the type so we can create our own  standard     On a machine in which sizeof int     4  we can define   typedef int int32   int32 i  int32 j        So when we transfer the code to a different machine where actually the size of long int is 4  we can just redefine the single occurrence of int   typedef long int int32   int32 i  int32 j

User · Answer

I notice that all the other answers here have focused almost exclusively on integral types  while the questioner also asked about floating-points   I don t think the C   standard requires it  but compilers for the most common platforms these days generally follow the IEEE754 standard for their floating-point numbers  This standard specifies four types of binary floating-point  as well as some BCD formats  which I ve never seen support for in C   compilers     Half precision  binary16  - 11-bit significand  exponent range -14 to 15 Single precision  binary32  - 24-bit significand  exponent range -126 to 127 Double precision  binary64  - 53-bit significand  exponent range -1022 to 1023 Quadruple precision  binary128  - 113-bit significand  exponent range -16382 to 16383   How does this map onto C   types  then  Generally the float uses single precision  thus  sizeof float    4  Then double uses double precision  I believe that s the source of the name double   and long double may be either double or quadruple precision  it s quadruple on my system  but on 32-bit systems it may be double   I don t know of any compilers that offer half precision floating-points   In summary  this is the usual    sizeof float    4 sizeof double    8 sizeof long double    8 or 16

User · Answer

Updated  C  11 brought the types from TR1 officially into the standard    long long int unsigned long long int   And the  sized  types from  lt cstdint gt    int8 t int16 t int32 t int64 t  and the unsigned counterparts     Plus you get    int least8 t int least16 t int least32 t int least64 t Plus the unsigned counterparts     These types represent the smallest integer types with at least the specified number of bits  Likewise there are the  fastest  integer types with at least the specified number of bits    int fast8 t int fast16 t int fast32 t int fast64 t Plus the unsigned versions     What  fast  means  if anything  is up to the implementation  It need not be the fastest for all purposes either

User · Answer

When it comes to built in types for different architectures and different compilers just run the following code on your architecture with your compiler to see what it outputs  Below shows my Ubuntu nbsp 13 04  Raring Ringtail  64 bit g  4 7 3 output  Also please note what was answered below which is why the output is ordered as such    There are five standard signed integer types  signed char  short int  int  long int  and long long int  In this list  each type provides at least as much storage as those preceding it in the list     include  lt iostream gt   int main   int argc  char   argv         std  cout lt  lt   size of char     lt  lt  sizeof  char   lt  lt  std  endl    std  cout lt  lt   size of short     lt  lt  sizeof  short   lt  lt  std  endl    std  cout lt  lt   size of int     lt  lt  sizeof  int   lt  lt  std  endl    std  cout lt  lt   size of long     lt  lt  sizeof  long   lt  lt  std  endl    std  cout lt  lt   size of long long     lt  lt  sizeof  long long   lt  lt  std  endl     std  cout lt  lt   size of float     lt  lt  sizeof  float   lt  lt  std  endl    std  cout lt  lt   size of double     lt  lt  sizeof  double   lt  lt  std  endl     std  cout lt  lt   size of pointer     lt  lt  sizeof  int     lt  lt  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

User · Answer

The C   standard does not specify the size of integral types in bytes  but it specifies minimum ranges they must be able to hold  You can infer minimum size in bits from the required range  You can infer minimum size in bytes from that and the value of the CHAR BIT macro that defines the number of bits in a byte  In all but the most obscure platforms it s 8  and it can t be less than 8  One additional constraint for char is that its size is always 1 byte  or CHAR BIT bits  hence the name   This is stated explicitly in the standard  The C standard is a normative reference for the C   standard  so even though it doesn t state these requirements explicitly  C   requires the minimum ranges required by the C standard  page 22   which are the same as those from Data Type Ranges on MSDN   signed char  -127 to 127  note  not -128 to 127  this accommodates 1 s-complement and sign-and-magnitude platforms  unsigned char  0 to 255  quot plain quot  char  same range as signed char or unsigned char  implementation-defined signed short  -32767 to 32767 unsigned short  0 to 65535 signed int  -32767 to 32767 unsigned int  0 to 65535 signed long  -2147483647 to 2147483647 unsigned long  0 to 4294967295 signed long long  -9223372036854775807 to 9223372036854775807 unsigned long long  0 to 18446744073709551615  A C    or C  implementation can define the size of a type in bytes sizeof type  to any value  as long as  the expression sizeof type    CHAR BIT evaluates to a number of bits high enough to contain required ranges  and the ordering of type is still valid  e g  sizeof int   lt   sizeof long     Putting this all together  we are guaranteed that   char  signed char  and unsigned char are at least 8 bits signed short  unsigned short  signed int  and unsigned int are at least 16 bits signed long and unsigned long are at least 32 bits signed long long and unsigned long long are at least 64 bits  No guarantee is made about the size of float or double except that double provides at least as much precision as float  The actual implementation-specific ranges can be found in  lt limits h gt  header in C  or  lt climits gt  in C    or even better  templated std  numeric limits in  lt limits gt  header   For example  this is how you will find maximum range for int  C   include  lt limits h gt  const int min int   INT MIN  const int max int   INT MAX   C     include  lt limits gt  const int min int   std  numeric limits lt int gt   min    const int max int   std  numeric limits lt int gt   max

User · Answer

unsigned char bits   sizeof X   lt  lt  3    where X is a char int long etc   will give you size of X in bits

User · Answer

1  Table N1 in article  The forgotten problems of 64-bit programs development   2   Data model

[c++] What does the C++ standard state the size of int, long type to be?

Examples related to c++

Examples related to c++-faq