C++ 是什么意思？ 标准规定了int、long的大小？

Question

我正在寻找有关基本 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（以及其他我没有想到的类型）在不同的架构和编译器下。

Answer 1

C++ 标准没有指定整数类型的大小（以字节为单位），但它指定了以位为单位的最小宽度（请参阅[basic.types.fundamental] p1)。 您可以从中推断出最小大小（以字节为单位）以及 定义一个字节中的位数。 在除了最不起眼的平台之外的所有平台中，它都是 8，并且不能小于 8。

char 的另一个限制是它的大小始终为 1 个字节，即 CHAR_BIT位（因此得名）。 请参阅[expr.sizeof] p1。

宽度在 [tab:basic.fundamental.width]。
最小/最大范围是这样的结果：

类型	宽度 ≥	最小 ≤	最大 ≥
signed char	8	-128	127
unsigned char	8	0	255
char	8	（见下文）	（见下文）
有符号短	16	-32768	32767
无符号短	16	0	65535
有符号整数	16	-32768	32767
无符号整型	16	0	65535
有符号长整型	32	-2147483648	2147483647
无	符号长整型32	0	4294967295
有符号长	整型64	-9223372036854775808	92233720368547 75807
<代码>unsigned long long	64	0	18446744073709551615

char 的范围是 signed char 或 unsigned char，具体取决于哪个char 的基础类型（请参阅 [basic.fundamental] p7）。

历史记录：在 C++20 之前，不保证有符号整数的补码，并且最小值大于 1。 例如，signed char 的最小值为 -127 或更低。 在 C++11 之前，宽度是通过 C 标准定义的。

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

1. 表达式 sizeof(type) * CHAR_BIT 的计算结果为足够高以包含所需范围的位数，并且
2. 类型的排序仍然有效（例如 sizeof(int) < = sizeof(长))。

不保证 float 或 double 的大小，但 double 提供的精度至少与 float 一样高。

实际的特定于实现的范围可以在 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();

Answer 2

对于 32 位系统，“事实上的”标准是 ILP32，即 int、long 和指针都是 32 位量。

对于 64 位系统，主要的 Unix “事实上”标准是 LP64 — long 和指针是 64 位（但 int 是 32 位）。 Windows 64 位标准是 LLP64 — long long 和指针是 64 位（但 long 和 int 都是 32 位）。

曾经，一些 Unix 系统使用 ILP64 组织。

这些事实上的标准均未由 C 标准 (ISO/IEC 9899:1999) 立法，但均得到 C 标准的允许。

而且，根据定义，sizeof(char) 为 1，尽管在​​ Perl 配置脚本中进行了测试。

请注意，有些机器 (Crays) 的 CHAR_BIT 远大于 8。这意味着，IIRC，sizeof(int) 也是 1，因为 char 和 int 是 32 位的。

Answer 3

实际上不存在这样的事情。 通常，您可以期望 std::size_t 表示当前架构上的无符号本机整数大小。 即 16 位、32 位或 64 位，但情况并不总是如此，正如对此答案的评论中指出的那样。

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

有五种标准有符号整数类型：signed char、short int、int、long int 和 long long int。 在此列表中，每种类型至少提供与其前面的列表一样多的存储空间。

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

如果您愿意，您可以静态（编译时）断言这些基本类型的大小。 如果假设的大小发生变化，它会提醒人们考虑移植您的代码。

Answer 4

有标准。

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

如果您关心可移植性，或者希望类型名称反映大小，您可以查看标头 ，其中可以使用以下宏：

int8_t
int16_t
int32_t
int64_t

int8_t保证为8位，int16_t保证为16位，等等。

Answer 5

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

Answer 6

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

• long long int
• unsigned long long int

以及

• int8_t
• int16_t
• int32_t
• int64_t
• 中的“sized”类型（以及 unsigned 对应项） ）。

再加上你得到：

• int_least8_t
• int_least16_t
• int_least32_t
• int_least64_t
• 加上未签名的对应项。

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

• int_fast8_t
• int_fast16_t
• int_fast32_t
• int_fast64_t
• 加上无符号版本。

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

Answer 7

C++ 标准是这样说的：

3.9.1，§2：

有五种有符号整数类型：
“有符号字符”，“短整型”，“整型”，
“长整型”和“长长整型”。 在
这个列表中，每种类型至少提供
与之前的存储一样多的存储
在列表中。 普通整数有
建议的自然尺寸
执行架构
环境（44）； 对方签了字
提供整数类型以满足
特殊需求。

(44) 也就是说，足够大以包含
INT_MIN 和 范围内的任何值
INT_MAX，如标头中定义
。

结论：这取决于您正在研究哪种架构。 任何其他假设都是错误的。

Answer 8

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

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

如果您想要固定大小的变量，您能做的最好的事情就是使用如下宏：

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

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

Answer 9

对于浮点数有一个标准(IEEE754)：浮点数是32位，双精度数是64位。这是一个硬件标准，而不是 C++ 标准，因此理论上编译器可以将 float 和 double 定义为其他大小，但实际上我从未见过使用任何不同的体系结构。

Answer 10

我们可以为该类型定义一个同义词，这样我们就可以创建自己的“标准”。

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

typedef int int32;

int32 i;
int32 j;
...

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

typedef long int int32;

int32 i;
int32 j;
...

Answer 11

有一个标准，并在各种标准文件（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;
}

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

约翰的回答包含了最好的描述，因为这些描述肯定是成立的。 无论您使用哪个平台，还有另一个很好的页面更详细地介绍了每种类型必须包含多少位：int 类型，在标准中定义。

我希望这有帮助！

Answer 12

当涉及不同架构和不同编译器的内置类型时，只需使用编译器在您的架构上运行以下代码即可查看其输出。 下面显示了我的 Ubuntu 13.04 (Raring Ringtail) 64 位 g ++4.7.3 输出。 另请注意下面的回答，这就是输出按如下方式排序的原因：

“有五种标准有符号整数类型：signed 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

Answer 13

1）《64位程序开发中被遗忘的问题"

2) "数据模型"

Answer 14

您可以使用：

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

datatype = int、long int 等。
您将能够看到您键入的任何数据类型的大小。

Answer 15

如前所述，大小应反映当前的架构。 如果您想了解当前编译器如何处理事情，您可以在 limits.h 中查看一下。

Answer 16

如果您对纯 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 。

下面的代码不提供任何保证，请仔细检查。
我也是元编程新手，请随意编辑和更正此代码。
使用 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;

}

Answer 17

正如其他人所回答的那样，“标准”都将大部分细节保留为“实现定义”，并且仅声明类型“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 位。）

如果您确实需要一个对象（在代表一个对象的一系列位的意义上 ）整数值）的特定位数，大多数编译器都有一些指定的方法； 但它通常不可移植，即使是在同一家公司针对不同平台制作的编译器之间也是如此。 一些标准和实践（尤其是 limit.h 等）足够常见，以至于大多数编译器都支持确定特定范围值的最佳拟合类型，但不支持确定所使用的位数。 （也就是说，如果您知道需要保存 0 到 127 之间的值，则可以确定您的编译器支持“int8”类型的 8 位，该类型将足够大以保存所需的整个范围，但不是像“int7”类型与 7 位完全匹配。）

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

Answer 18

我注意到这里的所有其他答案几乎都集中在整数类型上，而提问者也询问了浮点数。

我认为 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

Answer 19

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

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

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

MSDN 上的数据类型范围：

signed char：-127 到 127（注意，不是 -128 到 127；这适用于 1 的补码平台）
无符号字符：0 到 255
“plain”字符：-127 到 127 或 0 到 255（取决于默认字符符号）
有符号短：-32767 到 32767
无符号短：0 到 65535
有符号整数：-32767 到 32767
无符号整数：0 到 65535
有符号长：-2147483647 到 2147483647
无符号长整型：0 到 4294967295
有符号长长：-9223372036854775807 到 9223372036854775807
无符号长整型：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();

这是正确的，但是，您的说法也是正确的：
字符：1字节
短：2字节
整数：4字节
长：4字节
浮点数：4字节
double : 8 字节

因为 32 位架构仍然是默认且最常用的，并且自 32 位之前内存可用较少以来，它们一直保留这些标准大小，并且为了向后兼容和标准化，它保持不变。 即使 64 位系统也倾向于使用这些并进行扩展/修改。
请参考此以获取更多信息：

http://en.cppreference.com/w/cpp/语言/类型

Answer 20

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

这是 Microsoft 编译器的编译器：数据类型范围。

Answer 21

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

其中 X 是 char、int、long 等。将为您提供 X< 的大小/code> 以位为单位。

Answer 22

您可以使用 OpenGL、Qt 等。

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

Answer 23

在 64 位机器上：

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

Answer 24

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

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