002 C++的整数类型（Integer Types）

作者Lou Xiao, deepseek创建时间2025-04-02 05:30:34更新时间2025-04-02 05:30:34

1. 基本整数类型

1.1 标准整数类型

C++提供以下基本整数类型（按大小递增）：

类型名称	最小位数	典型位数	取值范围（典型）
`char`	8	8	-128 到 127 或 0 到 255
`short`	16	16	-32,768 到 32,767
`int`	16	32	-2,147,483,648 到 2,147,483,647
`long`	32	32/64	-2,147,483,648 到 2,147,483,647 (32位) 或更大(64位)
`long long`	64	64	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807

1.2 类型修饰符

signed：有符号类型（默认）
unsigned：无符号类型
short：短整数（至少16位）
long：长整数（至少32位）
long long：超长整数（至少64位，C++11引入）

2. 固定宽度整数类型（C++11）

2.1 标准固定宽度类型

定义在 <cstdint> 头文件中：

类型名称	位数	符号性	取值范围
`int8_t`	8	有符号	-128 到 127
`uint8_t`	8	无符号	0 到 255
`int16_t`	16	有符号	-32,768 到 32,767
`uint16_t`	16	无符号	0 到 65,535
`int32_t`	32	有符号	-2,147,483,648 到 2,147,483,647
`uint32_t`	32	无符号	0 到 4,294,967,295
`int64_t`	64	有符号	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
`uint64_t`	64	无符号	0 到 18,446,744,073,709,551,615

2.2 可选固定宽度类型

当平台不支持确切宽度时可能不存在：

类型名称	描述
`int_leastN_t`	至少N位的有符号整数
`uint_leastN_t`	至少N位的无符号整数
`int_fastN_t`	最快的有符号整数，至少N位
`uint_fastN_t`	最快的无符号整数，至少N位

2.3 最大宽度整数类型

类型名称	描述
`intmax_t`	平台支持的最大有符号整数类型
`uintmax_t`	平台支持的最大无符号整数类型

3. 整数类型特性

3.1 类型属性查询

C++11在<type_traits>和<limits>中提供：

 1.双击鼠标左键复制此行；2.单击复制所有代码。 
                                
                            #include <iostream>
                        
                            #include <limits>
                        
                            #include <type_traits>
                        
                            int main() {
                        
                                std::cout << "int size: " << sizeof(int) << " bytes\n";
                        
                                std::cout << "int is signed: " << std::is_signed<int>::value << "\n";
                        
                                std::cout << "int max: " << std::numeric_limits<int>::max() << "\n";
                        
                                std::cout << "int min: " << std::numeric_limits<int>::min() << "\n";
                        
                            }

3.2 整数提升规则

比int小的整数类型（如char）在运算前会被提升为int
如果操作数类型不同，会转换为更宽的类型
有符号和无符号混合时，有符号会转换为无符号

4. 整数字面量

4.1 字面量后缀

后缀	类型
无	`int`, `long`, `long long`（取决于大小）
`u`或`U`	`unsigned`
`l`或`L`	`long`
`ll`或`LL`	`long long`
`ul`或`UL`	`unsigned long`
`ull`或`ULL`	`unsigned long long`

4.2 字面量前缀

前缀	基数	示例
无	十进制	42
`0`	八进制	052
`0x`或`0X`	十六进制	0x2A
`0b`或`0B`	二进制（C++14）	0b101010

5. 整数运算注意事项

5.1 溢出问题

 1.双击鼠标左键复制此行；2.单击复制所有代码。 
                                
                            unsigned int a = 4294967295; // 最大无符号32位整数
                        
                            a += 1; // 溢出，结果为0
                        
                            int b = 2147483647; // 最大有符号32位整数
                        
                            b += 1; // 未定义行为

5.2 符号转换问题

 1.双击鼠标左键复制此行；2.单击复制所有代码。 
                                
                            unsigned int u = 10;
                        
                            int i = -5;
                        
                            if (i < u) { // i会被转换为无符号，导致意外结果
                        
                                // 可能不会执行如预期
                        
                            }

5.3 最佳实践

避免混合有符号和无符号运算
使用固定宽度类型进行跨平台数据交换
对可能溢出的运算进行检查
使用static_cast进行明确的类型转换

6. C++20新增特性

6.1 `std::ssize()`（C++20）

 1.双击鼠标左键复制此行；2.单击复制所有代码。 
                                
                            #include <vector>
                        
                            #include <iostream>
                        
                            int main() {
                        
                                std::vector<int> v{1, 2, 3};
                        
                                auto size = std::ssize(v); // 返回有符号的size_type
                        
                                std::cout << size; // 输出3
                        
                            }

6.2 带符号的`size_t`替代类型

std::ptrdiff_t和std::intptr_t用于指针差值和指针存储

7. 类型选择指南

使用场景	推荐类型
一般整数	`int`
数组索引	`size_t`
位操作	`unsigned`
文件大小	`uint64_t`
跨平台数据交换	`int32_t`/`uint32_t`等固定宽度类型
循环计数器	`int`或`size_t`（取决于是否与size比较）

8. 性能考虑

int通常是CPU处理最快的类型
较小的类型可能因对齐要求不节省空间
无符号类型在某些CPU上可能有更快的除法运算
现代编译器通常能优化简单的类型转换

文章目录

1	#include <iostream>
2	#include <limits>
3	#include <type_traits>
4
5	int main() {
6	std::cout << "int size: " << sizeof(int) << " bytes\n";
7	std::cout << "int is signed: " << std::is_signed<int>::value << "\n";
8	std::cout << "int max: " << std::numeric_limits<int>::max() << "\n";
9	std::cout << "int min: " << std::numeric_limits<int>::min() << "\n";
10	}

1	unsigned int a = 4294967295; // 最大无符号32位整数
2	a += 1; // 溢出，结果为0
3
4	int b = 2147483647; // 最大有符号32位整数
5	b += 1; // 未定义行为

1	unsigned int u = 10;
2	int i = -5;
3
4	if (i < u) { // i会被转换为无符号，导致意外结果
5	// 可能不会执行如预期
6	}

1	#include <vector>
2	#include <iostream>
3
4	int main() {
5	std::vector<int> v{1, 2, 3};
6	auto size = std::ssize(v); // 返回有符号的size_type
7	std::cout << size; // 输出3
8	}