变量和基本类型

为什么 C++ 中要给每个数据贴一张"标签"？

想象你面前有一排不同大小的盒子：火柴盒、鞋盒、收纳箱、搬家纸箱。你要放的是一颗纽扣——扔进搬家纸箱也行，但太浪费；要放的是一床被子——硬塞火柴盒肯定不行。

在 C++ 里，数据也有「盒子规格」：每种数据都得放进合适大小、合适样式的盒子里。你把一个整数放进一个小盒子，它干干净净刚好装下；把一个带小数的数字放进另一种盒子，它就按那种盒子的规矩摆放。要是所有东西都往同一种「万能麻袋」里塞呢？ 那电脑就帮不了你检查错误，空间要么白白浪费、要么根本装不下。

这一章就来认识 C++ 里这些「盒子」的种类、贴标签的规矩，以及怎么让数据在该出现的地方出现、在该消失的时候消失。

类型——给内存里的每个格子划定规矩

在 C++ 中，类型（type） 是程序最基本的「规矩」。任何一个变量在被使用之前，它的类型必须是确定的——编译器要在编译阶段就搞清楚：这个变量得分配几字节的内存、它的值能有多大范围、能对它做加减乘除还是不能。

类型不是运行时才起作用的概念——它从编译器看到你代码的第一刻起就参与工作。所以它处在程序编写的第一关口：在你敲完代码、点编译的那一刻，类型系统就开始逐行检查你的变量声明是否合法、运算是否合理。

基本算术类型——C++ 里有哪几种盒子

C++ 内置了以下几种 算术类型（arithmetic type）：

• 整型：short（2 字节）、int（4 字节）、long（4 或 8 字节）、long long（8 字节）——存整数
• 浮点型：float（4 字节，约 7 位有效数字）、double（8 字节，约 15 位有效数字）、long double（更大）
• 字符型：char（1 字节）、wchar_t（宽字符，2 或 4 字节）
• 布尔型：bool（1 字节）——只能存 true 或 false

下面这张对照表帮你直观感受各类型在内存里的"个头"：

类型决定了三件事：

1. 内存大小：int 占 4 字节，short 只占 2 字节——就像选盒子大小
2. 取值范围：unsigned char 只能存 0255，signed char 是 -128127
3. 能做什么运算：float 能算小数除法但可能有舍入误差，bool 不能做加减

带符号与无符号——同一段二进制，两种解读

当你写 int，它默认就是 signed int——能存正数、负数、零。如果你前面加一个 unsigned，比如 unsigned int，那它就只能存 ≥0 的整数。

两者的核心差别在于最高位的解读方式。C++ 使用 补码（two's complement）来表示有符号整数——在补码里，最高位为 1 就代表负数。下面这张图直观对比了同一个 8-bit 位模式在两种解读下的不同含义：

无符号类型常用来表示那些不可能为负数的量：数组下标、大小（sizeof 的返回值）、位掩码等。但在一般算术中，默认用 signed int 即可。

字面值常量——写在代码里的"裸值"

你写在程序里的那些直接写出来的值——42、3.14、'a'、"Hello"——叫作 字面值常量（literal）。编译器从字面值的写法就能推断出它的类型，不同的书写形式对应不同的类型：

几条记忆关键点：

• 整数 42 默认是 int；加 u 后缀变 unsigned、加 L 变 long、加 LL 变 long long
• 浮点数 3.14 默认是 double；加 f 后缀才能变成 float
• 字符用单引号 'a'、字符串用双引号 "a"（末尾暗藏一个 \0 结束符）
• 相邻字符串会被自动拼接："Hello" " World" 等价于 "Hello World"

变量——给内存格子起个名字

变量（variable） 就是给一块内存格子起的名字，加上一个类型标牌。在 C++ 里，变量必须先声明再使用。

几个容易混淆的概念必须分清：

C++11 引入的 列表初始化（list initialization） 是推荐的初始化方式——用花括号 {}：

int x = 0;    // 老写法（拷贝初始化）
int x{0};     // 列表初始化——更安全！会拒绝截断的窄化转换
double d{3.14};      // ✅
int i{d};            // ❌ 警告或报错：double → int 会丢失信息！
int i = d;           // ⚠️ 不会报错，悄悄截断为 3（危险！）

{} 花括号不会允许你"悄悄地"把 double 截成 int——这是列表初始化比传统 = 写法更安全的核心原因。

作用域——变量该在哪儿"出生"、在哪儿"死掉"

作用域（scope） 决定了变量在哪里可以看见、在哪里已经不存在了。C++ 的作用域由花括号 {} 划定边界。

嵌套作用域的核心规则：

1. 外层可见内不会：外层不能访问内层声明的变量——innerOnly 出了内层花括号就销毁了
2. 内层可见外层：内层可以访问外层的变量（前提是同名变量没有被遮蔽）
3. 同名遮蔽（shadowing）：内层声明了和外部同名的变量时，内部用内层的，外层的在内部暂时看不见

#include <iostream>
int global = 42;                      // 全局作用域
int main() {
    int local = 10;                  // main 函数作用域
    {
        int local = 20;             // 遮蔽了外层的 local！
        int innerOnly = 30;         // 只在这个块里存在
        std::cout << local;         // 输出 20（内层的）
        std::cout << global;        // 输出 42（全局的，能看见）
        std::cout << innerOnly;     // 输出 30（本块定义的）
    }
    std::cout << local;             // 输出 10（外层又可见了！）
    // std::cout << innerOnly;      // ❌ 编译错误！innerOnly 不存在了
    return 0;
}

Chapter 2 的完整类型契约

前面的内置类型、变量与作用域只覆盖 Chapter 2 的一部分。官方目录还要求掌握 Compound Types、const Qualifier、Dealing with Types 和 Defining Our Own Data Structures。它们共同回答：一个名字是否拥有对象、能否修改对象、类型从哪里来，以及怎样定义领域类型。

复合类型中，引用是已有对象的别名，定义时必须绑定且通常不能改绑；指针是独立对象，保存地址，可以改指向、比较或取空值。int& ref = value; 修改 ref 就修改 value；int* ptr = &value; 中 ptr 与 *ptr 分别是地址对象和被指对象。

const 限定符不等于编译期常量。const int n = read(); 的值可在运行时初始化；constexpr int width = 8 * 8; 则要求 constant expression。指针要分别读“指针本身 const”与“指向 const”：int* const p 不能改地址，const int* p 不能经 p 改对象。

类型推断包括 auto 与 decltype。auto 通常忽略顶层 const 和引用后推导变量类型；decltype(expr) 按表达式类别决定是否得到引用，decltype((name)) 对左值通常是引用，而 decltype(name) 对未加括号变量得到声明类型。

int value{42};
int& ref = value;
const int limit{64};
const int* pointerToConst = &limit;
auto copy = ref;              // int，复制 value
decltype(ref) alias = value;  // int&，仍是引用

自定义数据结构从 struct Sales_data 开始。定义应放在头文件并使用 include guard，保证所有 translation units 看到同一定义；对象定义则在需要存储的位置出现。Chapter 7 会继续加入封装、成员函数和构造函数，本章先建立“类型定义是共享契约”的观念。

动手：跟踪一个变量从出生到死亡

下面用一个最简程序，分步追踪变量的**出生（定义）→ 使用（运算/输出）→ 遮蔽（内层同名）→ 死亡（离开作用域）**的完整生命周期。

猜一猜：在内层代码块里把 local 改成 20 并输出，出了内层 local 又变成 10。变量到底是"被改回来了"还是"根本没被改"？通过下面 Stepper 一步步看解释。

代码速查：声明与初始化的写法

C++ 变量声明和初始化有几种不同写法，下面是在你需要时快速对照的关键例子：

// 定义 + 初始化
int a = 0;          // 拷贝初始化（C 风格写法）
int b{0};           // 列表初始化（C++11，安全！拒绝窄化转换）
int c(0);           // 直接初始化
int d;              // 仅定义，未初始化（值是垃圾！不推荐）
 
// 不同后缀决定字面值类型
auto x = 3.14;      // x 是 double
auto y = 3.14f;     // y 是 float
auto z = 42u;       // z 是 unsigned int
 
// 列表初始化的安全检测
double pi = 3.14159;
// int bad{pi};     // ❌ 报错：窄化转换
int good = pi;      // ⚠️ 通过但截断成 3

auto 关键字能让编译器自动推导变量类型（从初始值推断），在你不关心具体类型或类型名很长时很方便——auto 会根据初始值来推断变量的类型。

容易踩的坑

小结

• C++ 是强类型语言——每个变量在编译时就确定了类型、内存大小、取值范围和允许的运算
• 基本算术类型有整型（short/int/long/long long）、浮点（float/double/long double）、字符（char/wchar_t）、布尔（bool）
• 有符号和无符号类型的差别在于最高位的解读方式——混用会导致隐式转换和意料之外的结果
• 列表初始化 int x{0}; 比传统 = 写法更安全——它会拒绝窄化转换
• 作用域由花括号 {} 划定——变量从声明点活到所在块 } 结束；内层同名变量会遮蔽外层但不会修改它

#include <iostream>
int main() {
    unsigned int x = -1;
    int y;
    std::cout << y << std::endl;
    double pi = 3.14159;
    int rounded{pi};
    std::cout << rounded << std::endl;
    return 0;
}

#include <iostream>
int main() {
    int x = -1;                              // 负数用 signed
    int y{0};                                // 声明即初始化
    std::cout << y << std::endl;             // 输出 0
    double pi = 3.14159;
    int rounded = static_cast<int>(pi);      // 显式转换，表明你知道会截断
    std::cout << rounded << std::endl;       // 输出 3
    return 0;
}

#include <iostream>
int main() {
    int x = 10;
    {
        int x = 100;
        std::cout << x << std::endl;     // ① 输出？
    }
    std::cout << x << std::endl;         // ② 输出？
    {
        x = 50;
        std::cout << x << std::endl;     // ③ 输出？
    }
    std::cout << x << std::endl;         // ④ 输出？
    return 0;
}

#include <iostream>
int main() {
    char c1 = 65;
    char c2 = 'A';
    char c3 = '\x41';
    std::cout << c1 << c2 << c3 << std::endl;   // 输出 AAA
    int i = 'A';
    std::cout << i << std::endl;                 // 输出 65
    return 0;
}