关于C++ FAQ：C++标准说明了int，long类型的大小是什么？

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

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

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

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

1
2
3
4
5
6

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++ does not the size of the specify积分类型字节，but they must be en specifies最小靶道能to hold。你可以infer最小尺寸范围在bits from the required。你可以infer最小size字节from that and the value of the CHAR_BITthat the number of defines宏比特字节中(但最朦胧的平台是8，和EN - be less 8)。P＞＜／

一个额外的约束charis that for its size is Always(1位或字节，因此CHAR_BITthe name)。P＞＜／

by the minimum required靶道(22页)的标准是：P＞＜／

布尔数据类型由靶道：的MSDNP＞＜／

signed char(注：- 127，not to 127～128至127 1；这是accommodates余角和DC-SIGN和平台级)

unsigned char：0到255

"平原"或charsame as signed charunsigned char：范围定义，执行

signed short：～32767 to 32767

unsigned short：0到65535

signed int：～32767 to 32767

unsigned int：0到65535

signed long：～2147483647 to 2147483647

unsigned long：0到4294967295

signed long long：9223372036854775807 9223372036854775807 to

unsigned long longto 18446744073709551615：0

在C + +(或c)执行(the size of a type定义字节值sizeof(type)to any，只要P＞＜／

sizeof(type) * CHAR_BITevaluates the expression to a number of bits to contain靶道足够高来，和

of type is the序(例如sizeof(int) <= sizeof(long))仍然有效。

the actual implementation can be found特异靶道头在C或C + +，(或甚至更好，在模板std::numeric_limitsheader)。P＞＜／

for example，这样你会发现int最大范围为：P＞＜／

C：P＞＜／

1
2
3

#include <limits.h>
const int min_int = INT_MIN;
const int max_int = INT_MAX;

C + +：P＞＜／

1
2
3

#include <limits>
const int min_int = std::numeric_limits<int>::min();
const int max_int = std::numeric_limits<int>::max();

相关讨论

相反，C++标准使用"字节"来表示"1 EDOCX1×3"，而不是通常意义。
如果这个答案是用C++ 11范围更新的，那是很好的，我想它已经改变了(虽然不确定)。
@GSingh2011我认为范围没有改变，虽然增加了c99 inttypes.h的精确类型(例如int64-t)，但很容易分辨出这些类型的大小。
@大家：我改变了负范围。有人能告诉我为什么我的零钱被归还了吗？
@程序员阅读答案(括号中的第1点注释)，或实际标准的措辞(链接在答案中)。C标准包含1的补码体系结构，它与最广泛的2补码有不同的表示。最小保证范围几乎总是与实现提供的实际范围不同。
我怎样才能得到unsigned long long的最大、最小限制？
@ C++中的用户，EDCOX1，5，C，EDCOX1，6，(C99)。
注意这些是最小值。
@亚历克斯B你的回答中没有提到"双倍"这个词。你能更新你对浮点变量的答案吗？
@酷编码器：浮点是一个完整的额外的鱼水壶，很容易加倍的员额大小。
您链接到的"标准文档"是针对C的。
@Alex B签名int:2147483648到2147483647，来自msdn上的数据类型范围
@昆明谢，这是针对MSVC++-特定的文档，它只支持两个补充平台，标准也支持一个补充平台。
@昆明谢：只针对特定的编译器，针对特定的架构。这篇文章显示的是C++最小的范围，而不是VisualStudio在X64架构上的范围。
自本回答之日起，签名char类型的位在范围[-127..127]内是正确的。然而，新的C++标准增加了一点语言，以确保EDCOX1〔3〕可以表示(至少)256个不同的值。注意，[-127..127]只是255个不同的值。如果您的char类型是有符号的，它需要能够在这个范围之外再表示一个值，所以您几乎可以保证有-128。但这是特定于char，而不是其他积分类型。我不知道C是否有类似的要求。
"adrianmccarthy：[ 127 ] ...127仍然是准确的，和所有的全版本的C + +所需的256个不同的值。它仅仅是浪潮总是最后价值是什么。在我们的架构是在一些它的128，128，on和- 0…在理论上它可以是+∞。或1000(与值128 unrepresented 999)。C + +的规格不说。
mooing鸭"："所有版本的C + +所需的数据符号值为256字符[类型]"不，这是真的，直到它需要固定在更多最近的C + +的规格。有符号字符类型允许在以上的规格，有位模式不映射到一个不同的，所以他们的缺失，有256个不同的值。为无符号字符类型，所有可能的位模式的值代表的数字表示。论文要求不持有其他类型。"
"adrianmccarthy：迷人的，我没用一个"不数"的思想模式。理解。
"alexb困境了。

对于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位的。

相关讨论

知识的东西是stating + 1这是在一个情况下的物，而不是理论知识的东西。如果你想使用int是32位，64位长，如果你想使用。如果你想避免使用_ T.本地尺寸长因为它导致"平原"。一个应用程序不工作。
+ 1的答案。相反，eloff @：On the…如果你想使用[u]int32_t32位或64位相似的，如果你想使用[u]int64_t…如果你没有为他们的头，使一个下载或编译时，最好是选择搜索类型或静态assertions to verify the size。pubs.opengroup.org / / / / onlinepubs 009695299 basedefs zwnj stdint.h.ht &；& #毫升8203；如果不那么重要的精密尺寸与你照顾他们，那么你至少大，建议持有普通PC服务器平台的现代研究。
注意，它不只是一个老机器，克雷_ > 8位字符。例如一个字符_ DSP(16或32位。(湖如论文)
NOS的："谢谢你的链接。这是非常有用，有现代的，古怪的直流系统为例)。有好奇心，什么是代码集在这些机器？如果代码集是UTF-16字符0xFFFF)是不那么有效，如果是一个ISO 8859编码集编码集X，然后又不是一个有效的字符0xFFFF(从0x00到0xFF字符代码是有效的)。我还没有相信，那有一个检测的EOF的问题，但它可能是谨慎和中心，写作和使用一个或int get_char(FILE *fp, char *c)EOF函数返回0和*c集。
控制过程：a)tonyd @ uint32_t是只读在它behaves计算为无符号类型是在32位平台上int或较小的。我不认为有任何理由为什么C语言提供的标准不定义类型的行为是独立的大小int，但除非或直到C代码是这样的，这是应该独立将clunky int size和难读。
"supercat：这样做会invalidate所有整数提升规则。这是不可能的后向兼容性均值和发生在C是被遗忘的，那不是一辈子呢。
我的意思是："deduplicator提供新的类型的东西，我需要一个C如果64位处理器可以运行的代码是要在操作码操作数有效位数没有开支的大小选择(64位int会打破制作很多代码，但如果int是64位编译器必须提供确定性的行为。当过在int32流动，因此极限基准)。
"supercat：这不出现的案例在C11的WHERE uintN_t是必需的，是一个无符号整数类型是n位
@重复数据消除程序：向后兼容性只要求现有类型继续工作。如果C要定义新的类型uwrapN_t，在定义它们的实现上，这些类型必须遵守某些规则，这些规则自然会被uintN_t在int为n位的系统上遵守，并规定编译器必须拒绝任何使用这些类型的程序，其方式不能满足这些规则。编译器可用的类型，它应该有什么向后兼容性问题？
@除尘器：64位系统可以定义uwrap32_t，也可以不定义。使用uwrap32_t的代码可以直接在支持该类型的64位编译器上运行；如果需要在不支持该类型的编译器上运行此类代码，那么在包装行为实际重要的地方使用uwrap32_t会比在任何地方使用uint32_t更容易找到和修复此类位置。
@重复数据消除程序：与需要作为整数代数环的庞大代码体(同余mod 4294967296)所造成的非常真实的向后兼容性问题相比，此类类型的"向后兼容性"问题不会很小，并且在"int"大于32位的平台上缺少此类类型？
@乔尔：c11要求，考虑到uint32_t x=1,y=2;，在"int"为32位或更小的平台上，x-y的值必须为4294967295，在"int"为33位或更大的平台上，值必须为-1。此外，它还要求，如果"int"等于或小于32位，则必须使用模块化算法对所有x和y值进行评估；如果"int"等于或大于65位，则必须使用常规算法对所有x和y值进行评估，但如果"int"等于33到64位，则对x和y的大值可能发生的情况没有任何要求。
不仅仅是老一套，DSP部件的最小可寻址内存单元通常比8位大得多，例如，模拟设备sharc的sizeof(char)==sizeof(short)==sizeof(int)==1，并且不定义uint8_t或uint16_t，因为不存在这样的类型。当尝试移植一些SPI消息解析代码时，真是个惊喜！有些Ti的功能是一样的，而且至少有一些部分是两个单词长度的非幂次(24位IIRC)。

实践中没有这样的事情。你可以期望std::size_toften the size to Unsigned本地代表integer在线流架构。例如，16位，32位或64位，但它不是总是在茶馆as the to this out角的意见的答案。P＞＜／

as as the other新建的让-类型去，它真的depends on the编译器。有两excerpts taken from the current of the latest选秀工作的C + +标准：P＞＜／

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.

如果你想你可以(静态类型的编译时断言，这些基本sizeof the types)。它会提醒你的人想porting about change if the sizeof假设队列。P＞＜／

相关讨论

有标准。

C90标准要求

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

C99标准要求

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

这是C99规格。第22页详细说明了不同整型的尺寸。

以下是Windows平台的int类型大小(位)：

1
2
3
4
5
6

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

如果您关心可移植性，或者希望类型的名称反映大小，则可以查看标题，其中提供了以下宏：

1
2
3
4

int8_t
int16_t
int32_t
int64_t

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

相关讨论

如果你需要使用固定大小的类的类型，_ UInt32类型T(Unsigned 32位整数)是定义在指定的c99 stdint.h.他们。P＞＜／

相关讨论

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

双长整型
无符号长长整型

以及来自的"尺寸"类型

In 8T
因特16T
因特32
英特64
(以及未签署的副本)。

再加上你得到：

最小8T
最小16T
最小32位
最小64×T
加上未签字的副本。

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

国际紧固件8T
英特快16t
英特快32
英特快64
加上未签名的版本。

"fast"的含义(如果有)取决于实现。它也不一定是所有目的中最快的。

相关讨论

C++标准是这样说的：

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
.

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

不nope，there is for维大小.标准型.标准：only that……P＞＜／

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

最好的事情你可以做，如果你想在variables of is to使用固定宏维大小.这样：P＞＜／

1
2
3
4
5

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

然后你可以使用你的word to define变量。这是不是这样，但这是最便携的方式。P＞＜／

相关讨论

我们可以定义类型的同义词，这样我们就可以创建自己的"标准"。

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

1
2
3
4
5

typedef int int32;

int32 i;
int32 j;
...

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

1
2
3
4
5

typedef long int int32;

int32 i;
int32 j;
...

相关讨论

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

相关讨论

标准和EN is there is specified in the各种标准化文件(ISO，ANSI和whatnot)。P＞＜／

维基百科有大不同types and the page explaining the Max：他们可能商店integer在计算机科学。P＞＜／

不管一个人多是用标准C++编译器relatively You can find out using the following easily代码段：P＞＜／

1
2
3
4
5
6
7
8

#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数值can be found at roguewave限制。它包括在命令plethora of other to find out the Call You can的各种限制。This can be used with any type，size为任意conveys for example，性病：：streamsize。P＞＜／

最佳答案John's contains the description，as to hold是移调的那些。不管是什么，你的在线平台，there is another into more detail页上好，as to how many must contain each位类型：int types which are，the标准定义。P＞＜／

希望这helps！P＞＜／

1)"64位程序开发中被遗忘的问题"一文中的表N1

2)"数据模型"

你可以使用：

1	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。在这个列表中，每种类型提供的存储空间至少与列表中它前面的类型相同。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#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

相关讨论

as the size应该反思当前的上述结构。你可以在limits.htake a峰周围，如果你想看到你的编译器是如何流处理的东西。P＞＜／

相关讨论

正如其他人所回答的，"标准"都将大部分细节保留为"实现定义"，并且只声明类型"char"至少为"char-bis"宽，"char<=short<=int<=long<=long-long"(float和double与IEEE浮点标准非常一致，long-double通常与double相同，但可能在更当前的实现上做得更大)。

不具有非常具体和精确的值的部分原因是因为像C/C++这样的语言被设计成可移植到大量的硬件平台上，包括计算机系统，其中"char"字大小可以是4位或7位，或者甚至是"平均值为8／16／32／64位"的计算机。X.(这里的字大小意味着系统通常操作的比特宽度——同样，它不一定像家庭计算机用户所期望的那样总是8比特。)

如果您真的需要一个特定位数的对象(从表示整数值的一系列位的意义上来说)，大多数编译器都有一些指定该对象的方法；但是它通常不可移植，即使是在由AME公司制造的编译器之间，但也适用于不同的平台。有些标准和实践(尤其是limits.h等)非常常见，大多数编译器都支持为特定值范围确定最适合的类型，但不支持使用的位数。(也就是说，如果您知道需要将值保持在0到127之间，您可以确定编译器支持8位的"int8"类型，该类型将大到足以保持所需的完整范围，但不支持与7位完全匹配的"int7"类型。)

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

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

其背后的想法非常简单：创建一个包含char、int、short、long、long long(有符号和无符号版本)类型的列表，并扫描列表，然后使用数字限制模板选择具有给定大小的类型。

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

如果某些类型无法表示，它将被计算为stdtype:：null_类型，该类型也在该头中声明。

下面的代码没有保修，请仔细检查。我也是元编程的新手，请随意编辑和更正这段代码。用devc++测试(所以gcc版本大约是3.5)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

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

}

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

我不认为C++标准需要它，但是目前最常见的平台的编译器通常遵循IEEE74标准来执行浮点数字。这个标准指定了四种类型的二进制浮点(以及一些BCD格式，我从未在C++编译器中支持过)。

半精度(二进制16)-11位有效位，指数范围-14到15
单精度(二进制32)-24位有效位，指数范围-126到127
双精度(binary64)-53位有效位，指数范围-1022到1023
四倍精度(二进制128)-113位有效位，指数范围-16382到16383

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

总之，这是通常的：

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

相关讨论

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

其中X为char、int、long等。将以位为单位给出X的大小。

相关讨论

上述largely As You -恩河畔depends the编译器和平台。for this，check the ANSI标准，home.att.net http：/ / / / C jackklein inttypes.html ~P＞＜／

here is the one for the靶道：微软编译器的数据类型。P＞＜／

从Alex B中，C++标准没有指定字节中的整数类型的大小，但它指定了它们必须能够容纳的最小范围。您可以从所需的范围中以位为单位推断最小大小。您可以从中推断最小的字节大小和char-bit宏的值，该宏定义了一个字节中的位数(在除最模糊的平台之外的所有平台中，它是8个，不能小于8个)。

char的另一个约束是，它的大小始终是1字节或char_位(因此是名称)。

标准(第22页)要求的最小范围为：

以及msdn上的数据类型范围：

有符号字符：-127到127(注意，不是-128到127；这适用于1的补码平台)无符号字符：0到255"普通"字符：-127到127或0到255(取决于默认字符签名)有符号短：32767到32767无符号短：0到65535签名int:-32767到32767无符号整数：0到65535长签名：-2147483647到2147483647无符号长：0到4294967295长签：—9223372036854775807至9223372036854775807无符号长整型：0到18446744073709551615C++(或C)实现可以将字节大小(类型)定义为任何值，只要

表达式sizeof(type)*char_位的计算结果为足以包含所需范围的位数，以及类型的顺序仍然有效(例如sizeof(int)<=sizeof(long))。实际实现特定的范围可以在C中的报头中找到，或者在C++中找到(甚至更好的是，模板STD：：在页眉中的数字限制)。

例如，这是如何找到int的最大范围：

丙：

1
2
3

#include <limits.h>
const int min_int = INT_MIN;
const int max_int = INT_MAX;

C++：

1
2
3

#include <limits>
const int min_int = std::numeric_limits<int>::min();
const int max_int = std::numeric_limits<int>::max();

然而，这是正确的，你也说得对：字符：1字节短：2字节int:4字节长：4字节浮点：4字节双字节：8字节

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

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

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

例如，qt提供qint8(保证在qt支持的所有平台上为8位)、qint16、qint32、qint64、qint16、qint32等。

相关讨论

在64位计算机上：

1
2
3
4
5

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

相关讨论

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

短整数：2字节
长整数：4字节
长整型：8字节
整数：取决于编译器(16位、32位或64位)

相关讨论