C ++标准说明int，long类型的大小是什么？

我正在寻找有关基本C ++类型大小的详细信息。我知道这取决于体系结构（16位，32位，64位）和编译器。

但是C ++有什么标准吗？

我在32位体系结构上使用Visual Studio 2008。这是我得到的：

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

我试图找到，但没有成功，可靠的信息，表述的大小char，short，int，long，double，float（和其他类型的我没想到的），在不同的体系结构和编译器。

C ++标准未指定整数类型的大小（以字节为单位），但指定了它们必须能够容纳的最小范围。您可以从所需范围以位为单位推断最小大小。您可以从中推断出最小大小（以字节为单位），并CHAR_BIT可以定义定义字节中位数的宏的值。除了最晦涩的平台以外，其他所有平台均为8，并且不得小于8。这是因为它必须足够大，以容纳“ Unicode UTF-8编码形式的八位代码单元”。

另一个限制char是它的大小始终为1个字节或CHAR_BIT位（因此而得名）。这在标准中有明确规定。

C标准是C ++标准的规范性参考，因此，即使没有明确说明这些要求，C ++也需要C标准所要求的最小范围（第22页），与“数据类型范围”中的最小范围相同。MSDN：

1. signed char：-127到127（注意，不是-128到127；这可容纳1的补码和正负号平台）
2. unsigned char：0至255
3. “ plain” char：与signed char或相同的范围unsigned char，实现定义
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：-9222370036854775807至9223372036854775807
11. unsigned long long：0至18446744073709551615

C ++（或C）实现可以将类型的大小（以字节sizeof(type)为单位）定义为任何值，只要

1. 该表达式sizeof(type) * CHAR_BIT求值的位数足以包含所需的范围，并且
2. 类型的顺序仍然有效（例如sizeof(int) <= sizeof(long)）。

综合所有这些，我们保证：

• char，signed char和unsigned char至少为8位
• signed short，unsigned short，signed int，和unsigned int是至少16位
• signed long且unsigned long至少为32位
• signed long long并且unsigned long long至少为64位

不保证由有关的大小float或double不同之处在于double提供至少尽可能精确float。

实际的特定于实现的范围可以<limits.h>在C或<climits>C ++的标头中找到（甚至更好，可以std::numeric_limits在<limits>标头中模板化）。

例如，这是您将找到以下最大范围的方法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();

对于32位的系统中，“事实上的”标准是ILP32 -也就是int，long和指针都是32位的。

对于64位系统，主要的Unix“事实上”标准是LP64- long指针是64位（但是int32位）。Windows 64位标准为LLP64- long long指针为64位（但long同时int均为32位）。

一次，某些Unix系统使用ILP64组织。

C标准（ISO / IEC 9899：1999）都没有立法这些事实上的标准，但是所有标准都被它允许。

而且，顾名思义，sizeof(char)就是1，尽管在Perl的配置脚本测试。

需要注意的是有机器（Crays），其中CHAR_BIT大于8.这意味着，IIRC大得多，这sizeof(int)也是1，因为这两个char和int是32位。

实际上，没有这样的事情。通常，您可以期望std::size_t代表当前体系结构上的无符号本机整数大小。即16位，32位或64位，但并非始终如答案中所指出的那样。

至于所有其他内置类型，它实际上取决于编译器。以下是摘录自最新C ++标准的当前工作草案的两个摘录：

有五种标准的带符号整数类型：带符号的char，short int，int，long int和long long int。在此列表中，每种类型提供的存储量至少与列表中位于其前面的类型相同。

对于每种标准有符号整数类型，都有一个对应的（但不同的）标准无符号整数类型：unsigned char，unsigned short int，unsigned int，unsigned long int和unsigned long long int，每种类型占用相同的数量。存储并具有相同的对齐要求。

如果需要，可以静态（编译时）声明这些基本类型的大小。如果sizeof假设发生变化，它将提醒人们考虑移植您的代码。

有标准。

C90标准要求

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

C99标准要求

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

这是C99规格。第22页详细介绍了不同整数类型的大小。

这是Windows平台的int类型大小（位）：

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

如果您担心可移植性，或者希望类型的名称反映大小，则可以查看header <inttypes.h>，其中包含以下宏：

int8_t
int16_t
int32_t
int64_t

int8_t保证为8位，int16_t保证为16位，依此类推。

如果需要固定大小的类型，请使用stdint.h中定义的uint32_t（32位无符号整数）之类的类型。它们在C99中指定。

更新：C ++ 11将TR1的类型正式纳入标准：

• long long int
• 无符号long long int

和“大小”类型 <cstdint>

• int8_t
• int16_t
• int32_t
• int64_t
• （以及未签名的对应对象）。

另外，您得到：

• int_least8_t
• int_least16_t
• int_least32_t
• int_least64_t
• 加上未签名的副本。

这些类型表示至少具有指定位数的最小整数类型。同样，存在“最快”整数类型，其至少具有指定的位数：

• int_fast8_t
• int_fast16_t
• int_fast32_t
• int_fast64_t
• 加上未签名的版本。

“快速”的含义（如果有的话）取决于实现。它也不必是所有目的中最快的。

在C ++标准说，它是这样的：

3.9.1，第2节：

有五种有符号整数类型：“有符号字符”，“ short int”，“ int”，“ long int”和“ long long int”。在此列表中，每种类型提供的存储量至少与列表中位于其前面的类型相同。普通整数具有执行环境的架构所建议的自然大小（44）；提供其他有符号整数类型以满足特殊需要。

（44），即足够大以包含在header中定义的INT_MIN和INT_MAX范围内的任何值 <climits>。

结论：这取决于您正在使用的体系结构。任何其他假设都是错误的。

不，没有字体大小的标准。标准仅要求：

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

如果想要固定大小的变量，最好的办法是使用如下宏：

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

然后，您可以使用WORD定义变量。不是我喜欢这样，而是最便携的方式。

我们可以为类型定义同义词，以便我们可以创建自己的“标准”。

在sizeof（int）== 4的机器上，我们可以定义：

typedef int int32;

int32 i;
int32 j;
...

因此，当我们将代码传输到long int的大小实际上为4的另一台机器上时，我们可以重新定义int的单个出现。

typedef long int int32;

int32 i;
int32 j;
...

对于浮点数，有一个标准（IEEE754）：浮点数是32位，双精度点是64。这是一个硬件标准，不是C ++标准，因此编译器可以在理论上定义浮点数和双精度为其他大小，但是实际上我从来没有见过使用过任何不同功能的架构。

有一个标准，并且在各种标准文档（ISO，ANSI和诸如此类）中都有规定。

维基百科上有一个很棒的页面，解释了各种类型以及它们可以存储的最大值： 计算机科学中的整数。

但是，即使使用标准的C ++编译器，您也可以使用以下代码段轻松找到：

#include <iostream>
#include <limits>


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

可以在Roguewave上找到std :: numeric_limits的文档。它包括许多其他命令，您可以调用这些命令来找出各种限制。可以与任何传递大小的任意类型一起使用，例如std :: streamsize。

约翰的答案包含了最好的描述，因为肯定会得到保留。无论您使用的是哪种平台，都有一个很好的页面介绍了每种类型必须包含多少位的详细信息：int types，它们在标准中定义。

我希望这有帮助！

1）表N1的文章“ 64位程序开发的被遗忘的问题 ”

2）“ 数据模型 ”

您可以使用：

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

datatype = int，long int等等。你将能够看到您键入的数据类型为准大小。

当涉及到用于不同体系结构和不同编译器的内置类型时，只需在您的体系结构上与编译器一起运行以下代码，以查看其输出。下面显示了我的Ubuntu 13.04（Raring Ringtail）64位g ++ 4.7.3输出。还请注意下面的回答，这就是为什么按以下顺序订购输出的原因：

“有五种标准的带符号整数类型：带符号的char，short int，int，long int和long long int。在此列表中，每种类型提供的存储量至少与列表中位于其前面的类型相同。”

#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

如前所述，大小应反映当前的体系结构。你可以在采取峰值周围limits.h，如果你想看到你当前的编译器是如何处理的事情。

正如其他人回答的那样，“标准”都将大多数细节保留为“实现定义”，并且仅声明“ char”类型的宽度为“ char_bis”，而“ char <= short <= int <= long < = long long”（float和double与IEEE浮点标准非常一致，long double通常与double相同-但在更多当前的实现中可能更大）。

之所以没有非常具体和确切的值，部分原因是因为诸如C / C ++之类的语言被设计为可移植到大量硬件平台上，包括“ char”字长可能为4位的计算机系统。或7位，甚至是普通家用计算机用户所使用的“ 8- / 16- / 32- / 64位”计算机以外的其他值。（此处的字长表示系统正常运行多少位宽-同样，它并不总是像家用计算机用户所期望的那样是8位宽。）

如果您确实需要一个特定位数的对象（从一系列代表整数值的位的意义上来说），则大多数编译器都有某种方法来指定它；但这通常是不可移植的，即使是在ame公司制造的编译器之间，也适用于不同的平台。一些标准和实践（尤其是limits.h等）足够普遍，以致大多数编译器将支持确定特定值范围的最佳匹配类型，而不是所使用的位数。（也就是说，如果您知道需要保留0到127之间的值，则可以确定编译器支持“ int8”类型的8位，这足以容纳所需的整个范围，但不能满足“ int7”类型，它将与7位完全匹配。）

注意：许多Un * x源程序包使用“ ./configure”脚本，该脚本将探查编译器/系统的功能并输出合适的Makefile和config.h。您可能会检查其中一些脚本，以了解它们如何工作以及如何检测编译器/系统功能，并遵循它们的指导。

如果您对纯C ++解决方案感兴趣，那么我将使用模板和仅使用C ++标准代码在编译时根据位大小定义类型。这使解决方案可跨编译器移植。

背后的想法很简单：创建一个包含char，int，short，long，long long（有符号和无符号版本）类型的列表，然后扫描列表，并使用numeric_limits模板选择具有给定大小的类型。

包括此标头，您得到了8种类型stdtype :: int8，stdtype :: int16，stdtype :: int32，stdtype :: int64，stdtype :: uint8，stdtype :: uint16，stdtype :: uint32，stdtype :: uint64。

如果无法表示某种类型，它将被评估为还在该标头中声明的stdtype :: null_type。

下文提供的代码没有任何担保，请仔细检查。
我也是METAPROGRAMMING的新手，随时可以编辑和更正此代码。
经过DevC ++测试（所以gcc版本约为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;

其中X的一个char，int，long等会给你的大小X位数。

来自Alex B的C ++标准未指定整数类型的大小（以字节为单位），但指定了它们必须能够容纳的最小范围。您可以从所需范围推断最小大小（以位为单位）。您可以从中推断出最小大小（以字节为单位），以及定义一个字节中的位数的CHAR_BIT宏的值（在最晦涩的平台中，所有大小为8，并且不能小于8）。

char的另一个约束是其大小始终为1个字节，即CHAR_BIT位（因此而得名）。

标准（第22页）要求的最小范围是：

和MSDN上的数据类型范围：

有符号字符：-127到127（注意，不是-128到127；这可容纳1的补码平台）无符号字符：0到255“普通”字符：-127到127或0到255（取决于默认的字符签名）短：-32767至32767无符号短：0至65535有符号int：-32767至32767无符号int：0至65535有符号长：-2147483647至2147483647无符号长：0至4294967295有符号长:: -922337203685477575至922337203685477575807无符号长： 0到18446744073709551615 C（或C）实现可以将以字节为单位的类型大小sizeof（type）定义为任何值，只要

表达式sizeof（type）* CHAR_BIT计算得出足以包含所需范围的位数，并且类型的顺序仍然有效（例如，sizeof（int）<= sizeof（long））。实际的特定于实现的范围可以在C或C ++的标头中找到（甚至更好的是，标头中的模板化std :: numeric_limits）。

例如，这是您将找到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();

这是正确的，但是，您也说对了：char：1个字节短：2个字节int：4个字节长：4个字节float：4个字节double：8个字节

因为32位体系结构仍然是默认的且使用最多的，并且自32位之前的日子（内存不足）以来，它们一直保持这些标准大小，并且为了向后兼容和标准化，它保持不变。甚至64位系统也倾向于使用这些文件，并且具有扩展/修改。请参考此以获取更多信息：

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

我注意到这里所有其他答案几乎都只针对整数类型，而发问者也询问了浮点数。

我认为C ++标准不是必需的，但如今，用于最常见平台的编译器的浮点数通常遵循IEEE754标准。该标准指定了四种类型的二进制浮点数（以及某些BCD格式，我从未见过对C ++编译器的支持）：

• 半精度（binary16）-11位有效数字，指数范围-14至15
• 单精度（binary32）-24位有效位数，指数范围-126至127
• 双精度（binary64）-有效位53位，指数范围-1022至1023
• 四倍精度（binary128）-有效位113位，指数范围-16382至16383

那么，这如何映射到C ++类型？一般float使用单精度；因此，sizeof(float) = 4。然后double使用双精度（我相信这是名称的来源double），然后long double可能是双精度或四倍精度（在我的系统上是四倍精度，但在32位系统上可能是双精度）。我不知道有提供半精度浮点数的编译器。

总之，这是通常的：

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

正如您提到的-它在很大程度上取决于编译器和平台。为此，请检查ANSI标准， http://home.att.net/~jackklein/c/inttypes.html

这是用于Microsoft编译器的一个：数据类型范围。

您可以使用OpenGL，Qt等库提供的变量。

例如，Qt 提供 qint8（在Qt支持的所有平台上保证为8位），qint16，qint32，qint64，quint8，quint16，quint32，quint64等。

在64位计算机上：

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

根据大小，有四种类型的整数：

• 短整数：2个字节
• 长整数：4个字节
• long long整数：8个字节
• 整数：取决于编译器（16位，32位或64位）