C++ 数据类型：int、double、char、bool 等

为什么类型在 C++ 中很重要

当你用 int age = 30; 这样的显式类型声明一个值时，这个类型不只是一个标签：它告诉编译器要预留多少字节、怎样解释这些字节，以及哪些操作是合法的。类型选错了，你可能会悄无声息地丢失精度、发生溢出，或者触发未定义行为。

C++ 把内置类型分成几个家族：整数、浮点数、字符类型和布尔类型。我们逐个来看，然后再看那些容易让人栽跟头的规则。

基本类型

下面这个程序里，每种核心类型各有一个。注意字面量后缀（L、f、u）以及 char 用的单引号：

#include <iostream>
using namespace std;

int main() {
    int    count = 42;          // whole number, usually 32-bit
    long long big = 9000000000LL; // wider integer, the LL suffix
    double price = 19.99;       // 64-bit decimal (the default for decimals)
    float  ratio = 0.5f;        // 32-bit decimal - note the f
    char   grade = 'A';         // a single character, single quotes
    bool   passed = true;       // only true or false

    cout << count << " " << big << "\n";
    cout << price << " " << ratio << "\n";
    cout << grade << " " << passed << "\n"; // bool prints as 1 / 0
}

bool 默认打印为 1 或 0，而不是 true/false。char 用单引号：'A' 是一个字符，而 "A"（双引号）是字符串字面量，是完全不同的类型。这两个错误在刚开始学的时候极其常见。

大小并不固定

如果你学过 Java 这样的语言，这一点会让你最意外。C++ 标准只保证最小大小和相对顺序（short ≤ int ≤ long ≤ long long），实际大小取决于你的编译器和平台。务必用 sizeof 来确认：

#include <iostream>
using namespace std;

int main() {
    cout << "char:      " << sizeof(char)      << " byte\n";  // always 1
    cout << "short:     " << sizeof(short)     << " bytes\n";
    cout << "int:       " << sizeof(int)       << " bytes\n";
    cout << "long:      " << sizeof(long)      << " bytes\n";
    cout << "long long: " << sizeof(long long) << " bytes\n";
    cout << "double:    " << sizeof(double)    << " bytes\n";
}

在典型的 64 位 Linux 构建上，你会看到 int = 4，long = 8。但在 64 位 Windows 上，long 只有 4 个字节。正是这种可移植性上的差异，让你不应该写出假定 long 是 64 位的代码。

当你需要精确的宽度时，就使用 <cstdint> 中的定宽整数类型：

#include <iostream>
#include <cstdint>
using namespace std;

int main() {
    int8_t   a = -120;          // exactly 8 bits, signed
    uint16_t b = 65000;         // exactly 16 bits, unsigned
    int32_t  c = 2000000000;    // exactly 32 bits
    int64_t  d = 9000000000LL;  // exactly 64 bits, every platform

    cout << (int)a << " " << b << " " << c << " " << d << "\n";
}

对于文件格式、网络协议，或者任何必须在不同机器上表现完全一致的东西，都使用 int32_t/int64_t。注意这里的强制转换 (int)a：把 8 位类型送进输出流时，它会被当作字符而不是数字打印，所以要先转换。

有符号与无符号

每种整数类型都有两种形式。signed 类型可以保存负数；unsigned 类型不行，它用负数范围换来了更大的正数上限。普通的 int 默认是有符号的。

#include <iostream>
#include <climits>
using namespace std;

int main() {
    unsigned int u = 0;
    u = u - 1;          // does NOT become -1
    cout << u << "\n";  // wraps to 4294967295 (the max unsigned int)

    cout << "int max:  " << INT_MAX << "\n";
    cout << "uint max: " << UINT_MAX << "\n";
}

从无符号的 0 中减去一个数，结果不会变成负数，而是绕回成一个巨大的正数。这个问题总是让人中招，尤其是 .size() 返回的 size_t（一种无符号类型）：

vector<int> v = {1, 2, 3};
// DANGER: v.size() is unsigned. If v is empty, v.size() - 1 wraps
// to a gigantic number and the loop runs nearly forever.
for (size_t i = 0; i <= v.size() - 1; i++) { /* ... */ }

优先写 i < v.size()（永远不要写 <= size() - 1），或者干脆用基于范围的 for 循环绕开整个问题。

整数溢出是未定义行为

无符号数的绕回是有明确定义的，而有符号整数溢出在 C++ 中却是未定义行为。编译器可以做任何事：返回垃圾值、把检查优化掉，或者直接崩溃：

#include <iostream>
#include <climits>
using namespace std;

int main() {
    int maxInt = INT_MAX;            // 2147483647
    cout << maxInt << "\n";
    cout << maxInt + 1 << "\n";      // UNDEFINED BEHAVIOR - often wraps negative

    long long safe = (long long)maxInt + 1; // promote before adding
    cout << safe << "\n";            // 2147483648, correct
}

解决办法和任何语言中的溢出陷阱一样：在更宽的类型中做运算。在 + 之前先把其中一个操作数转换成 long long，让加法以 64 位进行。事后再转换结果就太晚了，溢出已经发生了。

选择合适的类型

对大多数代码来说，默认选择就够了：整数用 int，小数用 double。只有在确实有理由时才换用别的类型。

还有几个坑要记住。float 只有大约 7 位有效十进制数字，所以 0.1f + 0.2f 并不精确等于 0.3。除非你真的需要节省内存，否则优先用 double。另外，char 是有符号还是无符号取决于平台，所以如果你要对原始字节做运算，就明确写出 signed char 或 unsigned char。

下一步：auto 关键字

每次都把类型写出来很繁琐，而且有时类型很长，或者很难写出名字。C++ 让编译器通过 auto 关键字替你推导类型：auto x = 42; 让 x 成为 int，auto it = v.begin(); 让你不必敲出冗长的迭代器类型。下一页讲解什么时候 auto 能让代码更清晰，什么时候它又隐藏了太多信息。