QC++ / Qt 学习之路

现代 C++ 语法速览

掌握类型推导、const 语义与引用指针

入门第 2 / 48 章第一篇 · C++ 基础巩固

#变量、类型与"必须声明"

C++ 是静态类型语言:每个变量的类型在编译期就必须确定,之后不能改变。这和你熟悉的 Python / JavaScript 差别很大——Python 里 x = 1 然后 x = "hello" 完全合法,因为变量只是个贴在数据对象上的名字;Java 也要求声明类型,但从 Java 10 起有了 var,和 C++11 引入的 auto 思路类似。

先认识一下内置基本类型。和 Java 不同,C++ 的基本类型没有统一的跨平台位宽,标准只规定最小长度和相对大小关系(int 至少 16 位、long 至少 32 位,且 sizeof(int) <= sizeof(long))。真正需要精确宽度时请用 <cstdint> 里的 int32_t、int64_t、uint8_t 等固定宽度类型——这在序列化、网络协议、跨平台 Qt 代码里几乎是强制要求。

C++
#include <cstdint>
#include <iostream>
#include <limits>

int main() {
    int  count = 10;              // 通常 32 位
    long big   = 1'000'000L;      // 数字分隔符 ' 是 C++14 起支持的写法
    double pi  = 3.14159;
    bool  ok   = true;            // 布尔是真正的类型,不是 0/1 的别名
    char  grade = 'A';            // 单引号是字符,双引号是字符串,别混

    int32_t  fixed32 = -7;        // 精确 32 位有符号
    uint64_t fixed64 = 18'446'744'073'709'551'615ULL;

    // 未初始化的局部变量值是未定义的垃圾值,这是 C++ 最常见的 bug 源头
    // int danger;  // 危险:读取它的值属于未定义行为
    int safe{};                   // 值初始化,一定是 0

    std::cout << "sizeof(int)     = " << sizeof(int) << "\n";
    std::cout << "sizeof(int64_t) = " << sizeof(int64_t) << "\n";
    std::cout << "int 最大值      = " << std::numeric_limits<int>::max() << "\n";
    std::cout << safe << " " << fixed32 << " " << fixed64 << "\n";
    return 0;
}

注意 int safe{} 这种花括号初始化,它是 C++11 引入的统一初始化语法,还有一个额外好处:它禁止"窄化转换"(narrowing),比如 int x{3.14} 会直接编译失败,而 int x = 3.14 只会静默截断成 3。建议养成用 {} 初始化的习惯。

#auto:类型推导,不是动态类型

auto 让编译器根据初始化表达式推导变量类型。这一点务必和 Python 的动态类型划清界限:auto 推导发生在编译期,一旦推导完成类型就锁死了,之后给它赋别的类型照样报错。你可以把它理解成 Java 10+ 的 var 或 C# 的 var——语法糖,不是动态化。

auto 真正的价值在于:迭代器类型、std::map 的元素类型这些名字又长又啰嗦的东西,以及 Lambda 表达式这种你根本写不出类型名的东西。同时也别滥用——auto x = get_user(); 读代码的人完全不知道 x 是什么,此时宁可写全类型。

C++
#include <iostream>
#include <string>
#include <typeinfo>
#include <vector>

int main() {
    auto i = 42;            // int
    auto d = 3.14;          // double(字面量 3.14 默认就是 double)
    auto s = std::string("hi");  // std::string,不是 const char*
    auto f = 3.14f;         // float,后缀 f 决定类型

    std::vector<int> nums{1, 2, 3};
    auto it = nums.begin();              // 免去写 std::vector<int>::iterator
    // auto 推导出的类型与你手写完全一致,可以用 typeid 验证
    std::cout << typeid(it).name() << "\n";

    // 需要引用或常量时必须显式加修饰,auto 默认会"剥掉"引用和顶层 const
    const std::string name = "Qt";
    auto   copy  = name;        // 类型是 std::string(复制了一份)
    auto&  ref   = name;        // 类型是 const std::string&(真正的引用)
    const auto& cref = name;    // 显式只读引用,最常用

    // 类型一旦确定就不能改,下面这行会编译失败:
    // i = "not a number";

    std::cout << i << " " << d << " " << s << " " << f << "\n";
    std::cout << copy << " " << ref << " " << cref << "\n";
    return 0;
}

一个实用经验:函数参数和返回类型涉及容器时,auto 是不二之选;而涉及数值语义、需要读者一眼看出精度的地方,写全 int64_t / double 更负责。

#const 与 constexpr:两种"不变"

const 表示"这个东西初始化后不允许再改",是编译期和运行期都生效的只读约束。它和 JavaScript 的 const 表面相似,实质不同:JS 里 const obj = {} 之后你依然能改 obj.name,因为 const 只保护绑定;C++ 的 const 保护的是对象本身,通过 const 引用去写数据会直接编译报错。另外 final 在 Java 里对应的是"引用不可再指向别的对象",更接近 C++ 的 T* const(常量指针),而不是 const T*。

constexpr 是 C++11 起的加强版,语义是"这个值的计算必须能在编译期完成"。编译器可以在编译时就把它算出来塞进二进制,运行时零开销。C++17 里 constexpr 还能修饰 Lambda 和 if。

C++
#include <array>
#include <cstddef>
#include <iostream>

// 编译期计算阶乘:函数体在 C++14 起可以是多条语句
constexpr unsigned long long factorial(unsigned n) {
    unsigned long long result = 1;
    for (unsigned i = 2; i <= n; ++i) {
        result *= i;
    }
    return result;
}

int main() {
    const int port = 8080;                 // 运行期常量,语义上只读
    // port = 9090;                        // 编译错误:不能给 const 赋值

    constexpr int size = 10;               // 编译期常量
    std::array<int, size> buffer{};        // 数组长度必须是编译期常量,constexpr 才够格

    // constexpr 的值可以用在需要编译期常量的地方
    static_assert(factorial(5) == 120, "阶乘算错了");  // 编译期断言,零运行时成本

    constexpr auto f10 = factorial(10);    // 3628800,在编译时就算好了
    std::cout << "10! = " << f10 << "\n";
    std::cout << "buffer 长度 = " << buffer.size() << "\n";

    // const 变量如果初始化值是运行期才可知的,就不能当数组长度用
    int runtime_n = 0;
    std::cout << "请输入一个数字:";
    std::cin >> runtime_n;
    const int n = runtime_n;               // 合法,但 n 不是编译期常量
    // std::array<int, n> bad{};           // 编译错误
    return 0;
}

一句话区分:const 是"我承诺不改",constexpr 是"编译器现在就给我算出来"。能用 constexpr 的地方就用,代码既快又安全。

#引用 vs 指针:Java 的"引用"其实是 C++ 的指针

这是转语言过来最容易踩坑的一节。C++ 有两套间接访问机制:

  • 引用(T&):某个已存在对象的别名,必须初始化、不能为空、绑定后不能改指向。它更像 Python 里"同一个对象的另一个名字"——b = a 时 b 和 a 指向同一个列表。
  • 指针(T*):存放对象地址的变量,可以为空(nullptr)、可以重新指向别处、可以做算术运算。

关键对比:Java 里的 String s = new String("x") 中,s 更像 C++ 的指针而非引用——它可以被赋值为 null,也可以被重新指向另一个对象。Java 世界说的"引用",语义上对应 C++ 的指针(可空、可重定向),只是不能做指针算术、也不需要手动 delete。Python/JS 的变量名同理,更接近"带自动垃圾回收的指针"。

C++
#include <iostream>
#include <utility>

// 引用版本:调用方写 swap(a, b),函数内部改的就是调用者的变量
void swap_by_ref(int& a, int& b) {
    int tmp = a;
    a = b;
    b = tmp;
}

// 指针版本:调用方必须写 swap(&a, &b),函数内部要判空和解引用
void swap_by_ptr(int* a, int* b) {
    if (a == nullptr || b == nullptr) {
        return;                 // 指针可能为空,引用则不可能
    }
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

int main() {
    int x = 1, y = 2;
    swap_by_ref(x, y);
    std::cout << "x = " << x << ", y = " << y << "\n";   // 2, 1

    swap_by_ptr(&x, &y);        // 取地址要用 &
    std::cout << "x = " << x << ", y = " << y << "\n";   // 1, 2

    int value = 42;
    int* p = &value;            // p 存的是 value 的地址
    std::cout << "地址 = " << p << ", 值 = " << *p << "\n";

    *p = 100;                   // 通过指针写,value 变了
    std::cout << "value = " << value << "\n";

    int* np = nullptr;          // C++11 起用 nullptr,不要用 NULL 或 0
    if (np != nullptr) {
        std::cout << *np << "\n";   // 不会执行,保护了空指针解引用
    }
    return 0;
}

实践准则:能用引用就用引用,需要"可空"或"可改指向"时才用指针。现代 C++ 里裸指针更多用于"不拥有所有权的观察者",所有权问题交给下一章的智能指针。

#范围 for 与结构体

C++11 的范围 for 几乎和 Python 的 for item in list: 一模一样,写起来省心。唯一要注意的是默认写法会复制每个元素,对 std::string 或大对象来说白白浪费;想避免复制又不修改就用 const auto&,要修改就用 auto&。

结构体 struct 是打包数据的轻量工具。它和 class 在 C++ 里几乎完全等价,唯一区别是默认访问权限:struct 默认 public,class 默认 private。习惯上纯数据用 struct,带行为和不变量的用 class(下一章详述)。对比 Python 的 dataclass、JS 的 object literal,struct 的成员是固定且带类型的,编译期就确定了内存布局,这也是 C++ 性能优势的来源之一。

C++
#include <iostream>
#include <string>
#include <vector>

struct Student {
    std::string name;
    int         age{0};     // 类内成员初始值,C++11 起支持
    double      gpa{0.0};
};

// 传 const 引用:既不复制,也保证函数内部不会修改
void print(const Student& s) {
    std::cout << s.name << " (" << s.age << " 岁) GPA=" << s.gpa << "\n";
}

int main() {
    // 聚合初始化,顺序必须与成员声明顺序一致
    Student alice{"Alice", 20, 3.8};
    Student bob{.name = "Bob", .age = 21, .gpa = 3.5};  // 指定初始化器(C++20)

    std::vector<Student> roster{alice, bob};

    // 只读遍历:const auto& 是标准写法,避免复制每个 Student
    for (const auto& s : roster) {
        print(s);
    }

    // 需要修改元素时用 auto&(去掉 const)
    for (auto& s : roster) {
        s.age += 1;         // 全班长一岁
    }

    // 遍历内置数组也可以,编译器知道长度
    int scores[]{90, 85, 77};
    int total = 0;
    for (int v : scores) {  // 小类型直接复制反而更快
        total += v;
    }
    std::cout << "总分 = " << total << "\n";
    return 0;
}

顺带一提,C++17 还有结构化绑定:for (const auto& [name, age, gpa] : roster) 可以直接解包结构体成员,写起来非常像 Python 的元组解包,后续章节会用到。

#小结

  1. C++ 是静态类型语言,基本类型宽度因平台而异,需要精确位宽时用 <cstdint> 的 int32_t、int64_t。
  2. auto 是编译期类型推导(类似 Java 的 var),推导后类型即固定;需要引用语义时要显式写 auto& 或 const auto&。
  3. const 表示"只读",保护的是对象本身(强于 JS 的 const);constexpr 表示"必须在编译期求值",能用于数组长度、static_assert 等场景。
  4. 引用是别名(不可空、不可改指向),指针存地址(可空、可重定向);Java/Python 里的"引用"语义上更接近 C++ 的指针。优先用引用,可空场景用指针,空值用 nullptr。
  5. 范围 for 默认复制元素,读场景一律写 const auto&,写场景用 auto&。
  6. struct 与 class 仅默认访问权限不同;用 {} 做统一初始化可防止窄化转换。

#练习

  1. 写一个程序,用 sizeof 打印 int、long、long long、double、int64_t 在你机器上的实际字节数,思考为什么 long 在 Windows 和 Linux 上可能不同。
  2. 用 constexpr 写一个编译期计算斐波那契数列的函数,并用 static_assert 验证第 20 项等于 6765。
  3. 实现 void triple(int& value) 和 void triple(int* value) 两个重载版本,在 main 里分别调用,体会调用处写法的差异(triple(x) vs triple(&x))。
  4. 定义一个 struct Product { std::string name; double price; int stock; },用 std::vector<Product> 存若干商品,用范围 for 找出价格最高的一件并打印。再故意写 int x{3.14}; 与 int y = 3.14;,对比两种初始化在编译期的表现差异。
我的学习笔记笔记总览
笔记保存在本机浏览器(localStorage),换设备或清理缓存会丢失;重要内容请点「导出全部笔记」存成 .md 文件。