C＆＃x2B;＆＃x2B;什么是什么标准说int的大小，长吗？

携君以终年 2025-02-18 14:44:07

C ++标准未指定字节中积分类型的大小，但它指定位中的最小 width （请参阅 [basic.types.fundamental] p1 ）。您可以从该字节中推断出最小尺寸，以及 char_bit 宏观的值-A-BYTE-IN-ANSI-C89-90-C/437640＃437640“>定义字节中的位数。除了最晦涩的平台外，它是8个，它不能少于8

。位（因此名称）。参见 [expr.sizeof] p1 。

宽度在 [tab：basic.fundamental.width] 。
最小/最大范围是以下结果：

类型	宽度≥	最小≤	最大≥
`签名char`	8	-128	127
`unsigned char`	8	0	255
`chod> char` char	8	（请参阅下文）	（请参阅下文）
`签名的简短`	16	-32768	32767
`无符号短`	16	0	65535
`签名int`	16	-32768	32767 32767
`>无符号int`	0	65535
长	-2147483648	2147483647
签名长	32	0	4294967295
无		16	签名
32 >未签名的长长	64	0	184446744073709551615

char> char 的范围是签名>签名的char 或未签名的char ，取决于哪个是 char 的基础类型（请参阅 [basic.fundamentaltal> P7 ）。

历史注：在C ++ 20之前，不能保证签名整数的补充，最低限度更大。例如，签名的char 的最低限度为 -127 或更低。在C ++ 11之前，通过C标准定义宽度。

a c ++（或c）实现可以将字节中的类型大小定义为 sizef（type）只要

表达式 sizeof（type） * char_bit 评估到许多位高足以包含所需范围的位，并且
类型的排序仍然有效（例如 size> sizef（int）＆lt; = sizeof（long））。

没有保证 float 或 double 的大小，除了 double 至少提供的精度与 float 至少具有一样多的精度。。

实际实现特定范围可以在C中的＆lt; limits.h＆gt; 标题中找到，或者＆lt; gligits＆gt; 在C ++中（甚至更好，甚至更好，模板）＆lt; limits＆gt; 标题中的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();

The C++ standard does not specify the size of integral types in bytes, but it specifies a minimum width in bits (see [basic.types.fundamental] p1). 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). See [expr.sizeof] p1.

The widths are specified in [tab:basic.fundamental.width].
Minimum/maximum ranges are a consequence of that:

Type	Width ≥	Minimum ≤	Maximum ≥
`signed char`	8	-128	127
`unsigned char`	8	0	255
`char`	8	(see below)	(see below)
`signed short`	16	-32768	32767
`unsigned short`	16	0	65535
`signed int`	16	-32768	32767
`unsigned int`	16	0	65535
`signed long`	32	-2147483648	2147483647
`unsigned long`	32	0	4294967295
`signed long long`	64	-9223372036854775808	9223372036854775807
`unsigned long long`	64	0	18446744073709551615

The range of char is either that of signed char or unsigned char, depending on which is the underlying type of char (see [basic.fundamental] p7).

Historical note: Before C++20, two's complement wasn't guaranteed for signed integers, and the minimum was one greater. For example, the minimum of signed char was -127 or lower. Before C++11, the widths were defined through the C standard.

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) <= sizeof(long)).

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 <limits.h> header in C, or <climits> in C++ (or even better, templated std::numeric_limits in <limits> header).

For example, this is how you will find maximum range for 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();

回复收藏 0 原文

浪漫之都 2025-02-18 14:44:07

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

对于64位系统，主UNIX“事实上”标准是LP64 - 长，指针为64位（但是 int 是32位）。 Windows 64位标准是LLP64 - 长长，指针为64位（但是 long 和 int 均为32位）。

一次，一些UNIX系统使用了ILP64组织。

这些事实上的标准均未由C标准（ISO/IEC 9899：1999）立法，但所有这些标准都允许所有标准。

而且，根据定义，尽管Perl Configure脚本进行了测试，但 sizef（char）是 1 。

请注意， char_bit 大于8。和 int 是32位。

回复收藏 0 原文

沐歌 2025-02-18 14:44:07

实际上，没有这样的事情。通常，您可以期望 std :: size_t 表示当前体系结构上未签名的本机整数大小。即16位，32位或64位，但并非总是如此。

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

有五种标准的整数类型：签名的char，short int，int，long int和long long int。在此列表中，每种类型至少提供与列表之前的存储一样多。

对于每种标准签名的整数类型，都存在相应（但不同的）标准的无符号整数类型：未签名的char，未签名的短int，unsigned int，unsigned int，unsigned long int和未签名的长int，每个int占据相同数量的存储空间，并具有相同的对齐要求。

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

回复收藏 0 原文

最初的梦 2025-02-18 14:44:07

有标准。

C90标准要求

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

C99标准要求

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

。 Page 22详细信息不同的积分类型的大小。

这是Windows平台的int类型尺寸（位）：

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

如果您关注可移植性，或者想要该类型的名称反映大小，则可以查看标题＆lt; inttypes.h＆gt; ，有以下宏可用：

int8_t
int16_t
int32_t
int64_t

int8_t 保证为8位，并且保证 int16_t 是16位，等等。

There is standard.

C90 standard requires that

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

C99 standard requires that

sizeof(short) <= sizeof(int) <= sizeof(long) <= 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 <inttypes.h>, 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.

回复收藏 0 原文

淡水深流 2025-02-18 14:44:07

如果您需要固定尺寸类型，请使用。它们在

回复收藏 0 原文

青萝楚歌 2025-02-18 14:44:07

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

长长的int int int ints
unsigned long long int

和＆lt; cstdint＆gt;

int8_t
int16_t int16_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
加上无符号版本。

“快速”的意思（如果有的话）取决于实施。对于所有目的，它也不是最快的。

回复收藏 0 原文

有深☉意 2025-02-18 14:44:07

3.9.1，§2：

有五种签名的整数类型：
“签名char”，“ short int”，“ int”，
“ Long Int”和“ Long Long Int”。在
此列表，每种类型至少提供
与之前的存储一样多
在列表中。普通int有
自然尺寸由
执行架构
环境（44）;另一个签名
提供整数类型以满足
特殊需求。

（44），即，足够大以容纳
INT_MIN和
int_max，如标题中定义
＆lt;升高＆gt; 。

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

回复收藏 0 原文

百合的盛世恋 2025-02-18 14:44:07

不，没有类型尺寸的标准。标准只要求：

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

可以做的最好的事情

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

如果您想要固定尺寸的变量是使用这样的宏：那么您可以使用Word来定义变量，。这不是我喜欢这个，而是最便携式的方式。

Nope, there is no standard for type sizes. Standard only requires that:

sizeof(short int) <= sizeof(int) <= 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.

回复收藏 0 原文

王权女流氓 2025-02-18 14:44:07

对于浮点数，有一个标准（ieeee754）：floats是32位，双重和双打为64。这是一个硬件标准，而不是C ++标准，因此编译器可以从理论上定义浮点并加倍到其他尺寸，但是实际上，我从未见过使用任何不同的体系结构。

回复收藏 0 原文

绝情姑娘 2025-02-18 14:44:07

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

在一台尺寸（int）== 4的机器上，我们可以定义：

typedef int int32;

int32 i;
int32 j;
...

因此，当我们将代码转移到另一个机器中，其中长Int的大小为4时，我们可以重新定义int的单个出现。

typedef long int int32;

int32 i;
int32 j;
...

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;
...

回复收藏 0 原文

皓月长歌 2025-02-18 14:44:07

有一个标准，并在各种标准文档（ISO，ANSI和Whatnot）中指定。

Wikipedia有一个很好的页面，解释了它们可能存储的各种类型和最大值：
“ noreferrer”> Integer in Computer Science。

，即使使用标准的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 :: streamsize。

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

我希望这会有所帮助！

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 <iostream>
#include <limits>


int main() {
    // Change the template parameter to the various different types.
    std::cout << std::numeric_limits<int>::max() << 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!

回复收藏 0 原文

最美不过初阳 2025-02-18 14:44:07

当涉及到不同体系结构和不同编译器的类型时，只需使用编译器在架构上运行以下代码，以查看其输出的内容。下面显示了我的

“有五种标准的整数类型：签名的char，short int，int，int，long int，long int and 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

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 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 <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

回复收藏 0 原文

生生不灭 2025-02-18 14:44:07

1）表N1中的表“ 64位程序开发的遗忘问题“

2）” 数据模型”

回复收藏 0 原文

带上头具痛哭 2025-02-18 14:44:07

您可以使用：

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

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

You can use:

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

datatype = int, long int etc.
You will be able to see the size for whichever datatype you type.

回复收藏 0 原文

鹤舞 2025-02-18 14:44:07

如前所述，大小应反映当前的体系结构。如果您想查看当前的编译器如何处理事情，则可以在 limits.h 中达到顶峰。

回复收藏 0 原文

顾北清歌寒 2025-02-18 14:44:07

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

背后的想法非常简单：创建一个包含类型的char，int，short，long，long（签名和无符号版本）的列表，以及扫描列表，并使用numeric_limits模板使用给定尺寸的类型选择类型。

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

如果无法表示某种类型，它将被评估为STDTYPE :: NULL_TYPE在该标题中也声明。

下面的代码无保修，请仔细检查。
我也是元编程的新手，请随时编辑和更正此代码。
用DEVC ++测试（因此3.5左右的GCC版本）

#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;

}

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 <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;

}

回复收藏 0 原文

囍笑 2025-02-18 14:44:07

正如其他人所回答的那样，“标准”都将大多数细节都留为“实现定义”，并且只有该类型的“ char”在leat“ char_bis”宽，而“ char＆lt; = short＆lt; = short＆lt; = int = int＆lt; = long＆lt; = long long'（浮点和双重与IEEE浮点标准几乎一致，而长双人通常与双重相同 - 但在更新的当前实现中可能更大）。

没有非常具体和精确值的部分原因是因为C/C ++等语言被设计为可移植到大量硬件平台上 - 包括“ char”单词大小可能为4位的计算机系统或7位，甚至是“ 8-/16-/32-/64位”计算机外的普通家庭用户接触到的“ 8-/16-/32-/64位”的其他值。（这里的单词大小，这意味着系统通常运行的系统宽度 - 与家用计算机用户可能期望的那样，它并不总是8位。）

如果您真的需要一个对象特定数量位的积分值），大多数编译器都有某种方法来指定这一点；但是，即使是AME公司制作的编译器，但对于不同的平台，它通常也不是便携式的。某些标准和实践（尤其是Limits.H等）很常见，以至于大多数编译器都将支持在特定值范围内确定最佳拟合类型，但不使用所使用的位数。（也就是说，如果您知道需要保持0到127之间的值，则可以确定编译器支持一种“ INT8”类型的8位类型，该类型将足够大，可以保持所需的整个范围，但不像“ INT7”类型，它将是7位的确切匹配。）

注意：许多UN*X源软件包使用“ ./configure”脚本，该脚本将探测编译器/系统的功能并输出合适的makefile和config.h。您可能会检查其中一些脚本，以了解它们的工作原理以及如何探究Comiler/System功能，并遵循其领导。

回复收藏 0 原文

陌上青苔 2025-02-18 14:44:07

我注意到，这里的所有其他答案几乎完全集中在整体类型上，而发问者还询问了有关浮点的信息。

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

一半的精度（binary16）-11位显着，指数范围-14至15
单个精确度（二进制32） - 24位显着，指数范围-126至127
）-53位显着，指数范围-1022至1023
Quadruple Precision（Binary128）-113位显着，指数范围-16382至16383

双精度（二进制64 也是符合标准的其他尺寸。这些称为“扩展类型”。一个常见的例子是一个80位浮点，具有64位的显着性和指数范围为-16382至16383。过去也进行了40位浮点。

那么，如何将其映射到C ++类型上？通常， float 使用单个精度；因此， sizeof（float）= 4 。然后 double 使用双重精度（我相信这是名称 double ）的来源，而长通常是双重精度或80位精度（在我的系统上是80位，但在32位系统上可能是两倍）。从理论上讲，它也可能是四倍的精度。许多编译器还提供一半的精度浮点数作为扩展名，例如clang上的 _Float16 。

总而言之，这是通常的：

sizeof（float） = 4
sizeof（double） = 8
sizeof（long double） = 8或16

回复收藏 0 原文

埖埖迣鎅 2025-02-18 14:44:07

从Alex B中，C ++标准并未指定字节中积分类型的大小，但指定了它们必须能够保留的最小范围。您可以从所需范围内推断出最小尺寸。您可以从该字节中推断出最小尺寸，以及定义字节中的位数的char_bit宏的值（除了最晦涩的平台外，它是8个，并且不能少于8）。

char的另一个约束是其大小始终是1个字节或char_bit lit（因此名称）。

标准要求（第22页）所需的最小范围为：

MSDN上的数据类型范围：

签名char：-127至127（注意，不是-128至127；这可容纳1's -complement平台）
未签名的char：0至255
“普通” char：-127至127或0至255（取决于默认的char签名）
签名短：-32767至32767
未签名短：0至65535
签名INT：-32767至32767
未签名INT：0至65535
签名长：-2147483647至2147483647
未签名长：0至4294967295
长长签名：-922372036854775807至9223372036854775807
无签名长：0到184444444073709551615
C ++（或C）实现可以将字节大小（类型）中的类型大小定义为任何值，只要

表达式sizeof（type） * char_bit评估到足以包含所需范围的位数的数量，并且
类型的排序仍然有效（例如sizeof（int）＆lt; = 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个字节
浮点：4个字节
double：8字节，

因为32位体系结构仍然是默认和大多数使用的，并且自32位之前的内存较少时，它们一直保持这些标准尺寸，并且对于向后兼容和标准化，它们保持不变。即使是64位系统也倾向于使用这些并进行范围/修改。
请参考此信息以获取更多信息：

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

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) <= 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 <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();

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

回复收藏 0 原文

瞎闹 2025-02-18 14:44:07

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

这是Microsoft编译器的一个：

回复收藏 0 原文

世俗缘 2025-02-18 14:44:07

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

其中 x 是 char ， int ， long 等。 /代码>在位。

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

where X is a char,int,long etc.. will give you size of X in bits.

回复收藏 0 原文

七色彩虹 2025-02-18 14:44:07

您可以使用库提供的变量，例如 opentgl ，等。

en.wikipedia.org/wiki/qt_%28software%29“ rel =“ nofollow noreferrer”> qt qtglobal.html“ rel =“ nofollow noreferrer”>提供 qint8（保证在QT支持的所有平台上是8位），Qint16，Qint32，Qint64，Qint64，Quint8，Quint8，Quint8，Quint16，Quint16，Quint32，Quint32，Quint64等

回复收藏 0 原文

比忠 2025-02-18 14:44:07

在64位机器上：

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

On a 64-bit machine:

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

回复收藏 0 原文

沙与沫 2025-02-18 14:44:07

整数有四种类型的基于大小：

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

回复收藏 0 原文

C＆＃x2B;＆＃x2B;什么是什么标准说int的大小，长吗？

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

评论（24）

关于作者

相关话题

热门标签

推荐作者

李珊平

Quxin

范无咎

github_ZOJ2N8YxBm

若言

南…巷孤猫

友情链接

C＆＃x2B;＆＃x2B;什么是什么标准说int的大小，长吗？

如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

评论（24）

关于作者

相关话题

热门标签

推荐作者

李珊平

Quxin

范无咎

github_ZOJ2N8YxBm

若言

南…巷孤猫

友情链接

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。