为什么要学 C++？
作为 Java 开发者，你可能对 C++ 早有耳闻。C++ 是系统级编程的语言之王——操作系统、数据库引擎、游戏引擎、浏览器内核、高性能计算框架、AI 推理引擎，几乎所有的底层基础设施都是用 C++ 编写的。Java 本身（JVM）也是用 C++ 实现的。
C++ 能给你什么 Java 给不了的东西？
- 零成本抽象（Zero-overhead Abstraction）：使用高级抽象（如类、模板）而不产生运行时开销。C++ 的设计原则之一是"不为不需要的东西付出代价，为你使用的东西，你也不可能写出更优的手写代码"（“What you don’t use, you don’t pay for. What you do use, you couldn’t hand-code any better.”）
- 精细的内存控制：没有 GC 暂停，确定性的资源释放，适合实时系统和嵌入式场景
- 直接操作硬件：指针、内联汇编、内存映射 IO
- 极致性能：手动优化的空间远超 JIT 编译，适合对延迟和吞吐量有极端要求的场景
- 编译期计算：C++ 的模板元编程和 constexpr 使得大量计算可以发生在编译期，运行时零开销
学习 C++ 不是为了替代 Java，而是让你多一个看问题的视角——理解底层的内存布局、编译模型和资源管理哲学，会让你写 Java 代码时也更有底气。
核心思维转变：C++ 不是 Java 的方言
这是 Java 开发者学习 C++ 时最容易犯的错误——试图用 C++ 写 Java 风格的代码。C++ 的设计哲学和 Java 有本质区别，你需要主动完成以下几个思维转变。
1. 值语义 vs 引用语义
这是最根本的区别，也是 Java 开发者最需要转过弯来的概念。
Java：所有对象都在堆上分配，变量保存的是引用（可以理解为指针的指针）。赋值和传参复制的是引用，而不是对象本身。
// Java：b 和 a 指向同一个对象
List<String> a = new ArrayList<>();
List<String> b = a; // 复制引用，不复制对象
b.add("hello"); // a 也会受影响
System.out.println(a.size()); // 输出 1
C++：变量默认就是对象本身。赋值和传参会复制整个对象（深拷贝）。对象可以存在于栈上，不一定需要 new。
// C++：b 是 a 的独立副本
#include <vector>
#include <iostream>
int main() {
std::vector<int> a = {1, 2, 3};
std::vector<int> b = a; // 复制整个 vector！a 和 b 独立
b.push_back(4); // a 不受影响
std::cout << a.size(); // 输出 3，不是 4
return 0;
}
传参场景的对比最能体现差异：
// Java：传对象实际上是传引用的副本
void modify(List<Integer> list) {
list.add(100); // 原对象被修改
}
void reassign(List<Integer> list) {
list = new ArrayList<>(); // 只影响局部变量，外部不受影响
}
// C++：传值、传引用、传指针都有不同的语义
#include <vector>
#include <iostream>
void by_value(std::vector<int> v) {
v.push_back(100); // 操作的是副本，外部 vector 不受影响
}
void by_ref(std::vector<int>& v) {
v.push_back(100); // 操作的是原对象
}
void by_const_ref(const std::vector<int>& v) {
// v.push_back(100); // 编译错误！const 引用不允许修改
std::cout << v.size(); // 只读操作允许
}
int main() {
std::vector<int> vec = {1, 2, 3};
by_value(vec); // vec 不变，仍是 {1,2,3}
by_ref(vec); // vec 被修改，变成 {1,2,3,100}
std::cout << vec.size(); // 输出 4
return 0;
}
这对编码习惯的影响：
- ✅ 好习惯：小对象（int、double、指针等）用值传递；大对象用
const &传参，避免不必要的拷贝 - ✅ 好习惯：优先将对象分配在栈上，不需要
new - ❌ 坏味道：用 Java 的思维默认"对象=堆分配"，什么东西都
new - ❌ 坏味道：函数传参不加
const &，导致大对象反复拷贝
2. 内存管理：从依赖 GC 到 RAII
Java：你只管 new，GC 帮你回收。不用操心资源释放。但 GC 也带来了 STW（Stop-The-World）暂停和不确定的回收时机。
C++：没有 GC。你分配的内存必须自己释放。但 C++ 有更好的解决方案——RAII（Resource Acquisition Is Initialization，资源获取即初始化）。
RAII 的核心思想：将资源的生命周期绑定到对象的生命周期。对象构造时获取资源，对象析构时自动释放资源。
传统的 Java 资源管理：
// Java 需要手动 try-finally 或 try-with-resources
BufferedReader reader = null;
try {
reader = new BufferedReader(new FileReader("example.txt"));
String line = reader.readLine();
// 使用文件...
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try { reader.close(); } catch (IOException e) { }
}
}
// Java 7+ try-with-resources 改进了一些，但需要实现 AutoCloseable
try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
String line = reader.readLine();
}
C++ RAII 示例——文件自动关闭：
#include <fstream>
#include <iostream>
#include <string>
void read_file() {
std::ifstream file("example.txt"); // 构造时打开文件
if (!file) {
std::cerr << "Failed to open file\n";
return;
}
std::string line;
while (std::getline(file, line)) {
std::cout << line << '\n';
}
// 离开作用域时，file 对象被销毁，析构函数自动关闭文件
}
一个更完整的 RAII 异常安全示例：
#include <iostream>
#include <fstream>
#include <stdexcept>
#include <vector>
class DatabaseConnection {
public:
DatabaseConnection(const std::string& conn_str)
: connected_(true) {
std::cout << "Connected to database\n";
}
~DatabaseConnection() {
if (connected_) {
disconnect();
}
}
// 禁止拷贝
DatabaseConnection(const DatabaseConnection&) = delete;
DatabaseConnection& operator=(const DatabaseConnection&) = delete;
void query(const std::string& sql) {
if (!connected_) {
throw std::runtime_error("Not connected");
}
std::cout << "Executing: " << sql << '\n';
}
private:
bool connected_;
void disconnect() {
std::cout << "Disconnected from database\n";
connected_ = false;
}
};
void process_data() {
DatabaseConnection conn("db://localhost:3306/mydb");
std::ifstream file("data.csv");
if (!file) {
// 即使抛出异常，conn 也会在栈展开时被正确析构
throw std::runtime_error("Cannot open data.csv");
}
std::string line;
while (std::getline(file, line)) {
conn.query("INSERT INTO data VALUES ('" + line + "')");
}
// conn 和 file 都在离开作用域时自动释放
}
int main() {
try {
process_data();
} catch (const std::exception& e) {
std::cerr << "Error: " << e.what() << '\n';
// 即使异常发生，连接和文件都已安全关闭
}
return 0;
}
RAII 与智能指针：
智能指针（std::unique_ptr、std::shared_ptr）本质上就是 RAII 的产物。它们包装了堆上对象的生命周期管理。
#include <memory>
// ❌ 坏味道：Java 风格手动 new 和 delete
void bad_way() {
auto* obj = new std::vector<int>(100);
// ... 使用 obj ...
delete obj; // 容易忘记，或者在前面的 return 中跳过
}
// ✅ 好习惯：用 unique_ptr 自动管理堆对象生命周期
void good_way() {
auto obj = std::make_unique<std::vector<int>>(100);
// ... 使用 obj ...
// 离开作用域自动释放，异常安全
}
// ✅ 好习惯：优先使用栈对象，完全不需要堆分配
void best_way() {
std::vector<int> obj(100); // 栈上分配，零开销
// ... 使用 obj ...
// 自动释放
}
// unique_ptr 的完整示例：独占所有权
#include <memory>
#include <iostream>
class Resource {
public:
Resource() { std::cout << "Resource acquired\n"; }
~Resource() { std::cout << "Resource released\n"; }
void do_something() { std::cout << "Working...\n"; }
};
void demonstrate_unique_ptr() {
auto res = std::make_unique<Resource>();
res->do_something();
// std::unique_ptr<Resource> res2 = res; // 编译错误！unique_ptr 不能拷贝
auto res2 = std::move(res); // 所有权转移
res2->do_something();
// res 现在为空
} // res2 析构，自动释放 Resource
// shared_ptr 示例：共享所有权
void demonstrate_shared_ptr() {
auto res = std::make_shared<Resource>();
{
auto res2 = res; // 引用计数 +1
std::cout << "Use count: " << res.use_count() << '\n'; // 2
} // res2 析构，引用计数 -1
std::cout << "Use count: " << res.use_count() << '\n'; // 1
} // res 析构，引用计数归零，释放 Resource
好习惯与坏味道总结：
- ✅ 好习惯：用 RAII 管理所有资源（文件、锁、内存、网络连接、数据库事务等）
- ✅ 好习惯：默认使用
std::unique_ptr，需要共享时用std::shared_ptr - ✅ 好习惯：能用栈对象就不用堆对象
- ❌ 坏味道：到处
new但忘记delete，导致内存泄漏 - ❌ 坏味道：手动调用
delete——现代 C++ 几乎不需要裸delete - ❌ 坏味道：用
new创建对象然后传给shared_ptr（应该用std::make_shared）
3. 编译模型：头文件与分离式编译
Java：.java → javac → .class → JVM 加载 → JIT 编译 → 机器码。Java 的所有类信息都在字节码中，链接是运行时 JVM 完成的。
C++：.cpp → 编译器（g++/clang++）→ .o 目标文件 → 链接器 → 可执行文件。这是一个彻底的分离式编译模型。
┌─────────────┐ ┌──────────┐ ┌───────────┐ ┌────────────┐
│ main.cpp │───→│ compiler │───→│ main.o │───→│ │
├─────────────┤ │ (g++) │ ├───────────┤ │ linker │
│ utils.cpp │───→│ │───→│ utils.o │───→│ (ld) │───→ executable
├─────────────┤ └──────────┘ ├───────────┤ │ │
│ utils.hpp │ │ │ └────────────┘
└─────────────┘ └───────────┘
关键区别：
| 特性 | Java | C++ |
|---|---|---|
| 编译产物 | 字节码（.class） | 机器码（.o / .obj） |
| 跨平台 | 同一字节码到处运行 | 需为不同平台重新编译 |
| 声明与实现 | 不分离 | 头文件（声明）+ 源文件（实现） |
| 链接时机 | JVM 运行时 | 编译后的链接器阶段 |
| 依赖管理 | import 读取 .class | #include 预处理合并头文件 |
| 编译速度 | 快（增量增量粒度细） | 慢（每个 .cpp 独立编译再链接） |
头文件组织习惯：
// ──── my_class.hpp ──── （头文件：声明）
#ifndef MY_CLASS_HPP // 头文件保护符（Header Guard），防止重复包含
#define MY_CLASS_HPP
#include <string> // 用到的标准库
#include <vector>
// 好的头文件习惯：
// 1. 使用 #pragma once 或传统 #ifndef 保护
// 2. 只包含必要的头文件（前向声明优先）
// 3. 不要写 using namespace std; 在头文件中！
// 4. 写清楚文档注释
class MyClass {
public:
explicit MyClass(const std::string& name);
// const 成员函数：不修改对象状态
const std::string& getName() const;
void setName(const std::string& name);
// 静态成员函数
static int getInstanceCount();
private:
std::string name_;
static int instance_count_;
};
#endif // MY_CLASS_HPP
// ──── my_class.cpp ──── （源文件：实现）
#include "my_class.hpp" // 先包含自己的头文件（检查声明一致性）
#include <iostream> // 实现需要的头文件
int MyClass::instance_count_ = 0; // 静态成员定义
MyClass::MyClass(const std::string& name)
: name_(name) { // 初始化列表！不是函数体赋值
++instance_count_;
}
const std::string& MyClass::getName() const {
return name_;
}
void MyClass::setName(const std::string& name) {
name_ = name;
}
int MyClass::getInstanceCount() {
return instance_count_;
}
更好的做法：使用 #pragma once（非标准但主流编译器都支持，更简洁）：
// ──── my_class.hpp ────
#pragma once
#include <string>
class MyClass {
// ...
};
头文件中的坏味道：
- ❌ 坏味道：头文件中写
using namespace std;——会污染所有包含这个头文件的翻译单元 - ❌ 坏味道：头文件中包含不必要的头文件（增加编译时间）——用前向声明代替
- ❌ 坏味道：缺少头文件保护符，导致重复包含编译错误
- ❌ 坏味道：头文件中写函数实现（除非是 inline 函数或模板）
// ❌ 坏味道示例：不要这样写头文件
#include <iostream> // 不需要，仅用于打印
#include <vector>
#include <string>
using namespace std; // 灾难！所有包含此文件的地方都被污染
class BadClass {
void print() { // 非 inline 函数实现在头文件中
cout << "hello" << endl; // 多文件链接时可能重复定义
}
};
4. 异常处理
Java：异常是检查型（Checked Exception）和非检查型的，强制处理或声明。方法签名上用 throws 声明。
C++：异常不强制处理。C++17 开始可以用 noexcept 声明函数不抛异常。C++ 异常的开销较高（需要生成展开表、维护栈帧信息），很多项目（如 Google Chrome、LLVM）选择禁用异常，或者限制异常的使用范围。
void may_throw(); // 可能抛异常
void no_throw() noexcept; // 保证不抛异常（如果抛出，程序终止）
// noexcept 的一个常见用法：移动构造函数和移动赋值
// 如果移动操作保证不抛异常，标准库容器会优先使用移动而非拷贝
class MyBuffer {
public:
MyBuffer(MyBuffer&& other) noexcept
: data_(other.data_), size_(other.size_) {
other.data_ = nullptr;
other.size_ = 0;
}
private:
int* data_;
size_t size_;
};
C++ 异常的使用建议（来自现代 C++ 最佳实践）：
- 如果项目允许异常，用 RAII 保证异常安全（资源不会泄漏）
- 如果项目禁用异常（如 Google C++ Style Guide），用返回错误码或
std::optional/std::expected(C++23) noexcept对移动构造和 swap 特别重要——它允许标准库使用更高效的算法
// 使用 std::optional 替代异常（C++17）
#include <optional>
#include <string>
std::optional<int> parse_int(const std::string& s) {
try {
size_t pos;
int result = std::stoi(s, &pos);
if (pos == s.length()) return result;
return std::nullopt; // 解析失败但不抛异常
} catch (...) {
return std::nullopt;
}
}
// 使用方式
auto val = parse_int("42");
if (val.has_value()) {
std::cout << val.value() << '\n';
}
5. 类型系统的灵活性
Java：泛型是编译时类型擦除（Erasure），运行时没有类型信息。所有类都继承自 Object。
C++：模板是编译时实例化（Instantiation），每种类型生成独立的代码。没有统一的基类。你可以做更多的编译期计算（模板元编程）。
// Java 泛型——类型擦除
// List<Integer> 在运行期就是 List，没有 Integer 类型信息
// C++ 模板——编译期实例化
// std::vector<int> 和 std::vector<double> 是完全不同的类型，生成不同的代码
template <typename T>
T square(T x) {
static_assert(std::is_arithmetic_v<T>, "T must be arithmetic");
return x * x;
}
int main() {
auto a = square(5); // T = int, 生成 int square(int)
auto b = square(3.14); // T = double, 生成 double square(double)
// auto c = square("hi"); // 编译错误：static_assert 触发
return 0;
}
constexpr：编译期计算的新武器
现代 C++（C++11+）引入了 constexpr，比模板元编程更直观地表达编译期计算：
// 编译期计算阶乘
constexpr int factorial(int n) {
return n <= 1 ? 1 : n * factorial(n - 1);
}
// constexpr 数组长度——必须在编译期知道
int main() {
int arr[factorial(5)]; // 编译期计算为 120，合法！
static_assert(factorial(5) == 120, "factorial(5) should be 120");
return 0;
}
6. 初始化列表：成员初始化的正确方式
Java：成员变量可以在声明时赋值、在构造块中赋值、在构造函数中赋值。
class Example {
private int x = 10; // 声明时初始化
private List<String> list = new ArrayList<>();
public Example() {
x = 20; // 构造函数中重新赋值
}
}
C++：成员变量应该在初始化列表（Initializer List）中初始化，而不是在构造函数体内赋值。
#include <string>
#include <vector>
class Example {
public:
// ✅ 好习惯：使用初始化列表
Example(const std::string& name, int id)
: name_(name) // 直接初始化成员
, id_(id) // 基本类型
, data_(100, 0) // vector 直接构造，避免先默认构造再赋值
, ready_(true) // 也可以
{
// 如果这里赋值，name_ 会被先默认构造再赋值，效率更低
}
// ❌ 坏味道：函数体赋初值
// Example(const std::string& name, int id) {
// name_ = name; // name_ 先默认构造，再赋值
// id_ = id; // 基本类型影响不大
// }
private:
std::string name_; // 声明时不初始化
int id_;
std::vector<int> data_;
bool ready_;
};
注意：初始化列表的顺序必须和成员声明顺序一致，而不是初始化列表的书写顺序。
- ✅ 好习惯：优先使用初始化列表，而不是函数体赋值
- ❌ 坏味道：在构造函数体内给成员变量赋值（导致两次初始化：默认构造 + 赋值）
- ⚠️ 注意：初始化列表顺序必须和声明顺序一致（编译器会有警告）
实践：完整的 CMake 项目配置
Java 用 Maven/Gradle 管理项目。C++ 社区用 CMake 作为事实标准。
一个最小的 CMakeLists.txt：
cmake_minimum_required(VERSION 3.15)
project(MyCppProject VERSION 1.0.0 LANGUAGES CXX)
# 指定 C++ 标准
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF) # 禁用编译器扩展，更严格
# 开启警告
if(MSVC)
add_compile_options(/W4 /WX)
else()
add_compile_options(-Wall -Wextra -Wpedantic -Werror)
endif()
# 添加可执行文件
add_executable(my_app
src/main.cpp
src/utils.cpp
src/MyClass.cpp
)
# 包含头文件目录
target_include_directories(my_app PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/include
)
# 链接库
# target_link_libraries(my_app PRIVATE some_library)
构建命令：
# 配置（类似 Maven 的 pom.xml 解析）
cmake -B build -DCMAKE_BUILD_TYPE=Release
# 编译（类似 mvn compile）
cmake --build build
# 运行
./build/my_app
对于学习阶段，也可以用单文件直接编译（像写 Python 一样快速实验）：
g++ -std=c++17 -Wall -Wextra main.cpp -o main && ./main
C++ 编译工具链对照
| Java 工具 | C++ 对应 | 用途 |
|---|---|---|
| javac | g++ / clang++ | 编译器 |
| Maven/Gradle / Bazel | CMake / Bazel / Make | 构建系统 |
| Maven 仓库 (Maven Central) | vcpkg / Conan / apt | 包管理器 |
| JAR 包 | 静态库(.a) / 动态库(.so) | 库格式 |
| JUnit | Google Test / Catch2 | 测试框架 |
| Javadoc | Doxygen | 文档生成 |
| java -jar | ./executable | 运行 |
你的第一个 C++ 程序
#include <iostream> // 相当于 Java 的 import java.io.*
// C++ 的入口是 main 函数，返回 int
int main() {
std::cout << "Hello, C++!" << std::endl;
// std::endl 相当于 '\n' + flush，生产环境建议用 '\n' 避免频繁刷新
// std::cout << "Hello, C++!\n";
return 0; // 0 表示成功（和 main 返回值一样）；非 0 表示错误
}
编译和运行：
g++ -std=c++17 -Wall -Wextra main.cpp -o main
./main
-std=c++17 指定 C++ 标准版本。现代 C++ 开发应使用 C++17 或 C++20。
总结：思维转变清单
每次写 C++ 代码时，提醒自己：
- 值就是值，不是引用——变量就是对象本身。用
const &传参避免拷贝 - 栈是你的朋友——优先在栈上创建对象，不要什么都
new - RAII 是灵魂——资源管理靠对象的生命周期，不要手动管理。智能指针是你的好帮手
- 传参用引用——大对象用
const &传参。Java 没有引用语义等价物 - 没有 GC，但有智能指针——
std::unique_ptr是你的默认选择 - 编译慢是常态——做好增量编译和头文件管理的准备
- 现代 C++ 才是 C++——从 C++11/14/17/20 开始学，不要学 C with Classes
- 初始化列表 > 函数体赋值——成员初始化用初始化列表
- 头文件小心 using namespace std——只在 .cpp 文件里使用，绝不要在头文件中
下一篇我们将深入 C++ 的基础语法，从基本类型到 auto/decltype、constexpr、初始化列表等现代 C++ 特性。