第3章处理数据

基本数据类型

整数类型

有符号整数

类型	大小（字节）	范围
short	2	-32768 到 32767
int	4	-2147483648 到 2147483647
long	4 或 8	取决于平台
long long	8	-9223372036854775808 到 9223372036854775807

无符号整数

类型	大小（字节）	范围
unsigned short	2	0 到 65535
unsigned int	4	0 到 4294967295
unsigned long	4 或 8	取决于平台
unsigned long long	8	0 到 18446744073709551615

浮点类型

类型	大小（字节）	精度	范围
float	4	约6-7位有效数字	±3.4e38
double	8	约15-17位有效数字	±1.7e308
long double	8 或 16	取决于平台	取决于平台

字符类型

类型	大小（字节）	范围
char	1	-128 到 127 或 0 到 255（取决于实现）
signed char	1	-128 到 127
unsigned char	1	0 到 255
wchar_t	2 或 4	取决于实现
char16_t	2	0 到 65535（C++11+）
char32_t	4	0 到 4294967295（C++11+）
char8_t	1	0 到 255（C++20+，用于UTF-8编码）

布尔类型

类型	大小（字节）	值
bool	1	true 或 false

空类型

类型	描述
void	表示无类型，用于函数返回值和指针

C++23数据类型增强

std::expected（C++23+）

std::expected是C++23引入的类型，表示可能失败的操作结果，包含一个值或一个错误：

#include <expected>
#include <string>

std::expected<int, std::string> divide(int a, int b) {
    if (b == 0) {
        return std::unexpected("Division by zero");
    }
    return a / b;
}

int main() {
    auto result1 = divide(10, 2);
    if (result1) {
        // 操作成功，获取值
        std::cout << "Result: " << *result1 << std::endl;
    } else {
        // 操作失败，获取错误
        std::cout << "Error: " << result1.error() << std::endl;
    }
    
    auto result2 = divide(10, 0);
    if (result2) {
        std::cout << "Result: " << *result2 << std::endl;
    } else {
        std::cout << "Error: " << result2.error() << std::endl;
    }
    
    return 0;
}

std::mdspan（C++23+）

std::mdspan是C++23引入的多维数组视图，提供对连续内存的多维访问：

#include <mdspan>
#include <vector>

int main() {
    // 创建一个12元素的向量
    std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
    
    // 创建一个2x6的二维视图
    std::mdspan<int, std::extents<size_t, 2, 6>> md(data.data());
    
    // 通过多维索引访问元素
    md(0, 0) = 100;
    md(1, 5) = 200;
    
    // 遍历多维视图
    for (size_t i = 0; i < md.extent(0); ++i) {
        for (size_t j = 0; j < md.extent(1); ++j) {
            std::cout << md(i, j) << " ";
        }
        std::cout << std::endl;
    }
    
    return 0;
}

std::to_underlying（C++23+）

std::to_underlying是C++23引入的函数，用于将枚举转换为其底层类型：

#include <utility> // for std::to_underlying

enum class Color {
    Red, Green, Blue
};

enum class Status : int {
    Ok = 0,
    Error = 1,
    Warning = 2
};

int main() {
    Color c = Color::Green;
    int color_value = std::to_underlying(c);
    std::cout << "Color value: " << color_value << std::endl; // 输出：1
    
    Status s = Status::Error;
    int status_value = std::to_underlying(s);
    std::cout << "Status value: " << status_value << std::endl; // 输出：1
    
    return 0;
}

常量

字面常量

整数常量

123        // 十进制
0123       // 八进制（以0开头）
0x123      // 十六进制（以0x开头）
123U       // 无符号整数
123L       // 长整数
123LL      // 长长长整数
123UL      // 无符号长整数

浮点常量

123.456    // 十进制小数形式
123.456f   // float类型
123.456L   // long double类型
1.23456e2  // 科学计数法（1.23456 × 10²）
1.23456E-2 // 科学计数法（1.23456 × 10⁻²）

字符常量

'a'        // 字符常量
'\n'       // 转义序列（换行）
'\\'       // 转义序列（反斜杠）
'\''       // 转义序列（单引号）
'"'        // 转义序列（双引号）
'\0'       // 空字符
L'a'       // 宽字符常量
u8'a'      // UTF-8字符（C++11+）
u'a'       // UTF-16字符（C++11+）
U'a'       // UTF-32字符（C++11+）

字符串常量

"Hello"        // 字符串常量
"Line 1\nLine 2" // 包含转义序列的字符串
R"(raw string)"  // 原始字符串（C++11+）
u8"UTF-8"       // UTF-8字符串（C++11+）
u"UTF-16"        // UTF-16字符串（C++11+）
U"UTF-32"        // UTF-32字符串（C++11+）

布尔常量

1 2	true // 布尔真 false // 布尔假

const 常量

1
2
3

const int MAX_AGE = 120;
const double PI = 3.1415926535;
const std::string NAME = "C++";

constexpr 常量

C++11引入的编译时常量：

constexpr int MAX_SIZE = 100;
constexpr double CALCULATE_PI() {
    return 3.1415926535;
}
constexpr double PI = CALCULATE_PI();

consteval 常量（C++20+）

C++20引入的强制编译时计算常量，确保函数在编译期执行：

consteval int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

// 编译期计算
constexpr int result = factorial(5); // 正确，编译期计算

// 运行期计算会报错
// int n = 5;
// int result = factorial(n); // 错误，n是运行期变量

constinit 常量（C++20+）

C++20引入的常量初始化，确保变量在编译期初始化：

// 全局变量，在编译期初始化
constinit int global_value = 42;

// 静态变量，在编译期初始化
void function() {
    static constinit int static_value = 100;
}

// 注意：constinit只保证初始化在编译期，不保证变量是const
constinit int counter = 0;
void increment() {
    counter++; // 正确，counter不是const
}

枚举常量

// 枚举类型
enum Color {
    RED,    // 0
    GREEN,  // 1
    BLUE    // 2
};

// 带初始值的枚举
enum Direction {
    UP = 1,
    DOWN,
    LEFT,
    RIGHT
};

// 强类型枚举（C++11+）
enum class TrafficLight {
    RED,
    YELLOW,
    GREEN
};

// 使用
Color c = RED;
TrafficLight tl = TrafficLight::RED;

变量

变量声明

int age;                // 声明整型变量
double salary = 5000.0; // 声明并初始化浮点型变量
bool isStudent = true;  // 声明并初始化布尔变量
char grade = 'A';       // 声明并初始化字符变量
std::string name = "John"; // 声明并初始化字符串变量

变量初始化

拷贝初始化

1
2
3

int a = 10;
double b = 3.14;
std::string s = "Hello";

直接初始化

1
2
3

int a(10);
double b(3.14);
std::string s("Hello");

列表初始化（C++11+）

int a{10};
double b{3.14};
std::string s{"Hello"};
int c{}; // 零初始化

变量作用域

全局变量

在函数外部声明的变量，作用域为整个文件：

int globalVar = 100; // 全局变量

void function() {
    std::cout << globalVar << std::endl;
}

局部变量

在函数内部声明的变量，作用域为函数内部：

void function() {
    int localVar = 50; // 局部变量
    std::cout << localVar << std::endl;
}

块作用域变量

在代码块内部声明的变量，作用域为代码块内部：

void function() {
    int x = 10;
    {
        int y = 20; // 块作用域变量
        std::cout << x << " " << y << std::endl;
    }
    // std::cout << y << std::endl; // 错误：y超出作用域
}

函数参数

函数参数的作用域为函数内部：

1
2
3

void function(int param) { // param是函数参数
    std::cout << param << std::endl;
}

存储类别

auto 存储类别

局部变量的默认存储类别，在函数调用时创建，函数返回时销毁：

1
2
3

void function() {
    int x; // auto存储类别
}

static 存储类别

静态变量，在程序开始时创建，程序结束时销毁：

void function() {
    static int count = 0; // static存储类别
    count++;
    std::cout << count << std::endl;
}

extern 存储类别

声明外部变量，用于在一个文件中使用另一个文件中定义的全局变量：

// file1.cpp
extern int globalVar; // 声明外部变量

void function() {
    std::cout << globalVar << std::endl;
}

// file2.cpp
int globalVar = 100; // 定义全局变量

register 存储类别

提示编译器将变量存储在寄存器中（现代编译器通常会忽略此提示）：

1
2
3

void function() {
    register int counter; // register存储类别
}

运算符

算术运算符

运算符	描述	示例	结果
+	加法	5 + 3	8
-	减法	5 - 3	2
*	乘法	5 * 3	15
/	除法	5 / 3	1（整数除法）
/	除法	5.0 / 3.0	1.666…（浮点除法）
%	取模（余数）	5 % 3	2
++	自增（前缀）	++x	x+1，返回x+1
++	自增（后缀）	x++	x，返回x
–	自减（前缀）	–x	x-1，返回x-1
–	自减（后缀）	x–	x，返回x

关系运算符

运算符	描述	示例	结果
==	等于	5 == 3	false
!=	不等于	5 != 3	true
>	大于	5 > 3	true
<	小于	5 < 3	false
>=	大于等于	5 >= 3	true
<=	小于等于	5 <= 3	false
<=>	三路比较运算符（C++20+）	5 <=> 3	正数（表示大于）

三路比较运算符（C++20+）

C++20引入的三路比较运算符（<=>），也称为宇宙飞船运算符，用于简化比较操作的实现。它返回一个比较类别类型的值，表示两个操作数之间的关系：

正数：左操作数大于右操作数
零：左操作数等于右操作数
负数：左操作数小于右操作数

使用示例：

#include <compare>

// 基本类型的比较
int a = 5, b = 3;
auto result1 = a <=> b; // 返回正数（5 > 3）

// 字符串的比较
std::string s1 = "apple", s2 = "banana";
auto result2 = s1 <=> s2; // 返回负数（"apple" < "banana"）

// 结构体的比较
struct Point {
    int x, y;
    
    // 自动生成所有比较运算符
    auto operator<=>(const Point&) const = default;
};

Point p1{1, 2}, p2{3, 4};
bool less = p1 < p2; // 正确，自动生成
bool equal = p1 == p2; // 正确，自动生成

三路比较运算符的主要优点是：

简化代码：只需要定义一个运算符，就可以自动生成所有其他比较运算符
类型安全：返回类型携带了比较的语义信息
效率：避免了重复的比较操作

逻辑运算符

运算符	描述	示例	结果
&&	逻辑与	true && false	false
\|\|	逻辑或	true \|\| false	true
!	逻辑非	!true	false

赋值运算符

运算符	描述	示例	等价于
=	简单赋值	x = 5	x = 5
+=	加后赋值	x += 5	x = x + 5
-=	减后赋值	x -= 5	x = x - 5
*=	乘后赋值	x *= 5	x = x * 5
/=	除后赋值	x /= 5	x = x / 5
%=	取模后赋值	x %= 5	x = x % 5
<<=	左移后赋值	x <<= 2	x = x << 2
>>=	右移后赋值	x >>= 2	x = x >> 2
&=	按位与后赋值	x &= 5	x = x & 5
^=	按位异或后赋值	x ^= 5	x = x ^ 5
\|=	按位或后赋值	x \|= 5	x = x \| 5

位运算符

运算符	描述	示例	结果
&	按位与	5 & 3 (101 & 011)	1 (001)
\|	按位或	5 \| 3 (101 \| 011)	7 (111)
^	按位异或	5 ^ 3 (101 ^ 011)	6 (110)
~	按位取反	~5 (~~101)	-6 (在补码表示中)
<<	左移	5 << 2 (101 << 2)	20 (10100)
>>	右移	5 >> 2 (101 >> 2)	1 (1)

其他运算符

运算符	描述	示例	结果
sizeof	计算大小	sizeof(int)	4
&	取地址	&x	x的地址
*	解引用	*p	p指向的值
? :	条件运算符	x > y ? x : y	x和y中的较大值
.	成员访问	obj.member	obj的member成员
->	指针成员访问	ptr->member	ptr指向对象的member成员
[]	下标访问	arr[5]	arr的第6个元素
()	函数调用	func()	调用func函数
new	动态内存分配	new int	分配int大小的内存
delete	动态内存释放	delete p	释放p指向的内存

类型转换

类型转换是将一种类型的值转换为另一种类型的过程。C++提供了多种类型转换方式，包括隐式转换和显式转换。

隐式类型转换

隐式类型转换是编译器自动进行的类型转换，不需要程序员显式指定。

隐式转换的规则

算术转换：
- 当不同算术类型的操作数进行运算时，编译器会将较小的类型转换为较大的类型
- 转换顺序：bool → char/unsigned char/signed char → short/unsigned short → int/unsigned int → long/unsigned long → long long/unsigned long long → float → double → long double
整型提升：
- 小于int的整型类型（如char、short）在运算时会被提升为int
- 无符号类型的提升规则可能导致意外结果
其他隐式转换：
- bool转换：bool与整型之间的转换（true→1, false→0）
- 指针转换：任何指针都可以转换为void*，nullptr可以转换为任何指针类型
- 引用转换：派生类引用可以转换为基类引用
- 常量转换：非常量可以转换为常量

隐式转换的示例

// 算术转换
int i = 100;
double d = i; // int转换为double（安全，拓宽转换）

double pi = 3.14;
int intPi = pi; // double转换为int（不安全，窄化转换，丢失小数部分）

// 整型提升
char c1 = 'A'; // ASCII值65
char c2 = 'B'; // ASCII值66
int sum = c1 + c2; // c1和c2提升为int，sum=131

// bool转换
bool b = true;
i = b; // bool转换为int（true→1）

i = 0;
b = i; // int转换为bool（0→false）

i = 100;
b = i; // int转换为bool（非0→true）

// 指针转换
int* p = &i;
void* voidPtr = p; // int*转换为void*

// 引用转换
class Base {};
class Derived : public Base {};
Derived derived;
Base& baseRef = derived; // Derived&转换为Base&

隐式转换的安全性

拓宽转换：从小类型转换为大类型，通常是安全的（如int→double）
窄化转换：从大类型转换为小类型，可能丢失数据（如double→int、int→char）
符号转换：有符号类型与无符号类型之间的转换，可能导致意外结果
指针转换：不同类型指针之间的隐式转换可能导致类型错误

显式类型转换

显式类型转换是程序员通过特定语法显式指定的类型转换，也称为强制类型转换。

C风格的类型转换

double pi = 3.14;
int intPi = (int)pi; // C风格的类型转换

void* ptr = &pi;
double* dPtr = (double*)ptr; // C风格的指针转换

C风格类型转换的问题：

语法模糊，难以区分转换的目的
缺乏类型安全检查
难以在代码中查找

C++风格的类型转换

C++提供了四种类型转换运算符，每种用于特定的转换场景：

1. static_cast

用于相关类型之间的转换，编译时进行检查：

// 基本类型转换
double pi = 3.14;
int intPi = static_cast<int>(pi);

// 指针转换（相关类型）
class Base {};
class Derived : public Base {};
Base* basePtr = new Derived;
Derived* derivedPtr = static_cast<Derived*>(basePtr); // 不安全，无运行时检查

// 引用转换
Derived derived;
Base& baseRef = derived;
Derived& derivedRef = static_cast<Derived&>(baseRef);

// void*转换
int i = 100;
void* voidPtr = &i;
int* intPtr = static_cast<int*>(voidPtr);

2. dynamic_cast

用于多态类型之间的转换，运行时进行检查，确保转换的安全性：

class Base { virtual void f() {} }; // 必须有虚函数
class Derived : public Base { void f() override {} };

// 指针转换
Base* basePtr1 = new Derived;
Derived* derivedPtr1 = dynamic_cast<Derived*>(basePtr1); // 成功，返回Derived*

Base* basePtr2 = new Base;
Derived* derivedPtr2 = dynamic_cast<Derived*>(basePtr2); // 失败，返回nullptr

// 引用转换
try {
    Base base;
    Base& baseRef = base;
    Derived& derivedRef = dynamic_cast<Derived&>(baseRef); // 失败，抛出std::bad_cast异常
} catch (const std::bad_cast& e) {
    std::cout << "Bad cast: " << e.what() << std::endl;
}

3. const_cast

用于添加或删除const、volatile限定符：

// 删除const限定符
const int i = 100;
const int* constPtr = &i;
int* nonConstPtr = const_cast<int*>(constPtr);
// *nonConstPtr = 200; // 未定义行为，因为i是const

// 添加const限定符
int j = 200;
int* ptr = &j;
const int* constPtr2 = const_cast<const int*>(ptr);

// 删除volatile限定符
volatile int k = 300;
volatile int* volPtr = &k;
int* nonVolPtr = const_cast<int*>(volPtr);

4. reinterpret_cast

用于不相关类型之间的转换，最危险的类型转换：

// 指针类型转换
int i = 100;
int* intPtr = &i;
double* doublePtr = reinterpret_cast<double*>(intPtr); // 危险，可能导致未定义行为

// 整数与指针之间的转换
uintptr_t ptrValue = reinterpret_cast<uintptr_t>(intPtr);
int* newIntPtr = reinterpret_cast<int*>(ptrValue);

// 函数指针转换
typedef void (*FuncPtr)();
int* funcPtr = reinterpret_cast<FuncPtr>(0x12345678); // 极其危险

类型转换的最佳实践

优先使用C++风格的类型转换：
- 更安全：dynamic_cast提供运行时检查
- 更清晰：明确转换的目的
- 更易维护：易于在代码中查找和分析
避免不必要的类型转换：
- 设计时考虑类型匹配
- 使用模板和泛型减少类型转换
- 优先使用类型安全的容器和算法
注意转换的安全性：
- 避免窄化转换，使用static_cast时要确保转换是安全的
- 对于多态类型，优先使用dynamic_cast确保安全
- 避免使用reinterpret_cast，除非绝对必要
- 使用const_cast时要确保不会修改const对象
使用显式转换明确意图：
- 即使是安全的隐式转换，在关键位置使用显式转换可以提高代码可读性
- 对于可能有歧义的转换，使用显式转换明确意图

类型转换与类型安全

类型安全的重要性：
- 避免运行时错误和未定义行为
- 提高代码的可读性和可维护性
- 减少调试时间和错误修复成本
类型安全的实践：
- 使用强类型枚举（enum class）替代传统枚举
- 避免使用void*和原始指针
- 使用智能指针管理动态内存
- 优先使用标准库容器和算法
- 利用C++的类型系统进行编译时检查
现代C++中的类型转换：
- 使用std::variant和std::any进行类型安全的多态
- 使用概念（Concepts）约束模板参数类型
- 使用std::optional表示可能不存在的值
- 使用std::expected表示可能失败的操作结果

类型推导的高级用法

auto与引用和const

int i = 100;

// 推导为值类型
auto a1 = i; // int

// 推导为引用类型
auto& a2 = i; // int&
const auto& a3 = i; // const int&

// 推导为指针类型
auto* a4 = &i; // int*
const auto* a5 = &i; // const int*

// 与表达式一起使用
auto a6 = i + 1.0; // double

decltype与表达式值类别

int i = 100;

// 推导变量类型
decltype(i) j = 200; // int

// 推导表达式类型

// 左值表达式
decltype((i)) k = i; // int&（注意双括号）

// 右值表达式
decltype(i + 1) l = 300; // int

// 函数调用表达式
std::string s = "Hello";
decltype(s.size()) m = 5; // size_t

类型推导与模板

// 函数模板中的类型推导
template<typename T>
void func(T param) {
    // T的类型由调用时的实参推导
}

// 自动推导返回类型
template<typename T, typename U>
auto add(T t, U u) {
    return t + u; // 返回类型由t + u的类型推导
}

// 使用decltype指定返回类型
template<typename T, typename U>
auto multiply(T t, U u) -> decltype(t * u) {
    return t * u;
}

// 类模板中的类型推导（C++17+）
template<typename T>
class MyClass {
public:
    MyClass(T value) : value(value) {}
    T getValue() const { return value; }
private:
    T value;
};

// 推导指引（C++17+）
template<typename T>
MyClass(T) -> MyClass<T>;

// 使用
auto mc = MyClass(42); // 推导为MyClass<int>

类型别名

typedef

typedef unsigned long ulong;
typedef std::vector<int> IntVector;
typedef void (*FunctionPtr)(int);

ulong x = 100;
IntVector vec;
FunctionPtr func;

using 别名声明（C++11+）

using ulong = unsigned long;
using IntVector = std::vector<int>;
using FunctionPtr = void (*)(int);

ulong x = 100;
IntVector vec;
FunctionPtr func;

// 模板别名
template<typename T>
using Vec = std::vector<T>;

Vec<int> intVec;
Vec<double> doubleVec;

类型信息

typeid 运算符

#include <typeinfo>

int i = 100;
double d = 3.14;

std::cout << typeid(i).name() << std::endl; // 输出int的类型名
std::cout << typeid(d).name() << std::endl; // 输出double的类型名

// 运行时类型信息（RTTI）
class Base { virtual void f() {} };
class Derived : public Base {};

Base* basePtr = new Derived;
std::cout << typeid(*basePtr).name() << std::endl; // 输出Derived的类型名

类型特性（C++11+）

#include <type_traits>

// 类型判断
std::cout << std::is_integral<int>::value << std::endl; // 1（true）
std::cout << std::is_floating_point<int>::value << std::endl; // 0（false）

// 类型转换
std::cout << std::is_convertible<int, double>::value << std::endl; // 1（true）

// 类型修改
using SignedInt = std::make_signed<unsigned int>::type;
using UnsignedInt = std::make_unsigned<int>::type;
using AddPointer = std::add_pointer<int>::type;
using RemovePointer = std::remove_pointer<int*>::type;

数值极限

#include <limits>

// 整型极限
std::cout << "int min: " << std::numeric_limits<int>::min() << std::endl;
std::cout << "int max: " << std::numeric_limits<int>::max() << std::endl;

// 浮点型极限
std::cout << "double min: " << std::numeric_limits<double>::min() << std::endl;
std::cout << "double max: " << std::numeric_limits<double>::max() << std::endl;
std::cout << "double epsilon: " << std::numeric_limits<double>::epsilon() << std::endl;

// 其他特性
std::cout << "int is signed: " << std::numeric_limits<int>::is_signed << std::endl;
std::cout << "int digits: " << std::numeric_limits<int>::digits << std::endl;

小结

本章介绍了C++中的数据类型、常量、变量、运算符和类型转换等核心概念。通过本章的学习，你应该能够：

掌握C++的基本数据类型，包括整型、浮点型、字符型、布尔型和空类型
理解各种常量的定义和使用方法，包括字面常量、const常量、constexpr常量和枚举常量
掌握变量的声明、初始化和作用域规则
熟悉C++的各种运算符及其优先级和结合性
理解类型转换的原理和方法，包括隐式类型转换和显式类型转换
掌握C++11引入的类型推导和类型别名特性
了解类型信息和数值极限的获取方法

数据是程序的基础，掌握好C++的数据处理能力对于编写高效、可靠的程序至关重要。在后续章节中，我们将学习如何使用这些数据类型和运算符来构建更复杂的程序结构，如控制语句、函数、数组、指针、类等。

C++提供了丰富的数据类型和运算符，这使得它既可以处理底层的系统编程任务，也可以处理高层的应用开发任务。通过合理选择和使用数据类型，你可以编写出更高效、更安全、更易维护的代码。

第3章 处理数据