现代 C++ 语法速览
掌握类型推导、const 语义与引用指针
#变量、类型与"必须声明"
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 代码里几乎是强制要求。
#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 是什么,此时宁可写全类型。
#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。
#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 的变量名同理,更接近"带自动垃圾回收的指针"。
#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++ 性能优势的来源之一。
#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 的元组解包,后续章节会用到。
#小结
- C++ 是静态类型语言,基本类型宽度因平台而异,需要精确位宽时用
<cstdint>的int32_t、int64_t。 auto是编译期类型推导(类似 Java 的var),推导后类型即固定;需要引用语义时要显式写auto&或const auto&。const表示"只读",保护的是对象本身(强于 JS 的const);constexpr表示"必须在编译期求值",能用于数组长度、static_assert等场景。- 引用是别名(不可空、不可改指向),指针存地址(可空、可重定向);Java/Python 里的"引用"语义上更接近 C++ 的指针。优先用引用,可空场景用指针,空值用
nullptr。 - 范围
for默认复制元素,读场景一律写const auto&,写场景用auto&。 struct与class仅默认访问权限不同;用{}做统一初始化可防止窄化转换。
#练习
- 写一个程序,用
sizeof打印int、long、long long、double、int64_t在你机器上的实际字节数,思考为什么long在 Windows 和 Linux 上可能不同。 - 用
constexpr写一个编译期计算斐波那契数列的函数,并用static_assert验证第 20 项等于 6765。 - 实现
void triple(int& value)和void triple(int* value)两个重载版本,在main里分别调用,体会调用处写法的差异(triple(x)vstriple(&x))。 - 定义一个
struct Product { std::string name; double price; int stock; },用std::vector<Product>存若干商品,用范围for找出价格最高的一件并打印。再故意写int x{3.14};与int y = 3.14;,对比两种初始化在编译期的表现差异。