前端开发者快速掌握 C++：那些你必须理解的核心概念

const a = { name: "Tom" };
const b = a;          // b 和 a 指向同一个对象
b.name = "Jerry";
console.log(a.name);  // "Jerry" —— a 也变了

data class User(var name: String)
val a = User("Tom")
val b = a             // b 和 a 指向同一个对象
b.name = "Jerry"
println(a.name)       // "Jerry"

struct User {
    std::string name;
};

User a{"Tom"};
User b = a;           // ⚠️ b 是 a 的完整副本，两个独立对象
b.name = "Jerry";
std::cout << a.name;  // "Tom" —— a 没变！

// 方式 1：引用（别名，但不能重新指向其他对象）
User& ref = a;        // ref 就是 a 的另一个名字
ref.name = "Jerry";   // a.name 也变了

// 方式 2：智能指针（最接近 JS/Kotlin 的行为）
auto a = std::make_shared<User>(User{"Tom"});
auto b = a;            // a 和 b 指向同一个对象，引用计数 = 2
b->name = "Jerry";
std::cout << a->name;  // "Jerry" —— 和 JS 行为一致

void PrintUser(User user) {    // ⚠️ user 是 a 的拷贝
    user.name = "Modified";     // 不影响外部的 a
}

User a{"Tom"};
PrintUser(a);
std::cout << a.name;  // 还是 "Tom"

void PrintUser(const User& user) {  // 不拷贝，不修改
    std::cout << user.name;
}

function createUser() {
    const user = { name: "Tom" };
    return user;
}  // user 变量离开作用域，但对象不会被销毁
   // GC 会在"某个时候"发现没人引用它了再回收

const u = createUser();  // 对象通过返回值传出去了，继续活着

void DoSomething() {
    User user{"Tom"};      // 在栈上创建
    // ... 使用 user ...
}  // ← user 在这里自动销毁，不需要手动操作

// ❌ 错误：返回了一个已销毁对象的引用
User& CreateUser() {
    User user{"Tom"};
    return user;      // user 马上就销毁了，返回的引用指向"尸体"
}

// ✅ 正确：返回值（拷贝出去）
User CreateUser() {
    User user{"Tom"};
    return user;      // 拷贝一份返回，原始 user 销毁没关系
}

User* user = new User{"Tom"};   // 在堆上创建
// ... 使用 user ...
delete user;                     // 你必须手动销毁
user = nullptr;                  // 好习惯：避免后续误用

auto user = std::make_shared<User>(User{"Tom"});
// 不需要 delete，最后一个 shared_ptr 销毁时自动释放

void Example() {
    auto a = std::make_shared<User>(User{"Tom"});  // 引用计数 = 1
    {
        auto b = a;    // 引用计数 = 2
    }                  // b 离开作用域，引用计数 = 1
}                      // a 离开作用域，引用计数 = 0 → 对象自动销毁

JS/Kotlin:
  创建对象 ──→ 随便用 ──→ 没人引用了 ──→ GC 某天回收（你不用管）

C++ 栈对象:
  进入 {} ──→ 对象创建 ──→ 使用 ──→ 离开 {} ──→ 立即销毁

C++ 智能指针:
  make_shared ──→ 引用计数=1 ──→ 拷贝:+1 / 销毁:-1 ──→ 计数=0 ──→ 立即销毁

C++ 裸指针:
  new ──→ 使用 ──→ 你必须 delete ──→ 忘了就泄漏，delete两次就崩溃

// JS — 循环引用不是问题
class Node {
    constructor() { this.parent = null; this.child = null; }
}
const parent = new Node();
const child = new Node();
parent.child = child;
child.parent = parent;  // 循环引用
// 当 parent 和 child 变量都不再使用时，
// GC 的标记-清除算法能发现它们从根不可达，正常回收 ✅

// C++ — 循环引用 = 内存泄漏！
auto parent = std::make_shared<Node>();
auto child = std::make_shared<Node>();
parent->child = child;    // child 引用计数 = 2
child->parent = parent;   // parent 引用计数 = 2
// parent 变量销毁 → parent 引用计数 = 1（child 还持有）
// child 变量销毁 → child 引用计数 = 1（parent 还持有）
// 谁都降不到 0，永远不会释放 → 💥 内存泄漏

class Node {
    std::shared_ptr<Node> child;    // 父 → 子：强引用（拥有）
    std::weak_ptr<Node> parent;     // 子 → 父：弱引用（观察，不拥有）
};

auto config = std::make_unique<Config>();

// ❌ 不能拷贝
auto copy = config;  // 编译错误！

// ✅ 只能移动（转移所有权）
auto moved = std::move(config);
// 现在 config == nullptr，moved 拥有这个对象

// 第一步：从 shared_ptr 创建 weak_ptr
std::weak_ptr<User> weak = shared_user;

// 第二步：使用前必须 lock() 升级
auto strong = weak.lock();

// 第三步：检查是否有效
if (strong) {
    strong->DoSomething();  // 安全
}
// 如果 strong == nullptr，说明对象已经被销毁了

void Process() {
    std::string name = "Tom";        // name 在这里诞生
    {
        std::vector<int> nums = {1, 2, 3};  // nums 在这里诞生
        // 可以使用 name 和 nums
    }                                        // ← nums 在这里死亡（自动销毁）
    // 这里只能用 name，nums 已经不存在了
}                                    // ← name 在这里死亡

void WriteFile() {
    std::lock_guard<std::mutex> lock(mutex);  // 构造 = 加锁
    // ... 写文件操作 ...
    // 如果这里抛异常了怎么办？
}  // ← lock 销毁 = 自动解锁（无论正常返回还是异常退出都会执行）

// JS 中你需要 try-finally 来保证清理
mutex.lock();
try {
    // ... 写文件操作 ...
} finally {
    mutex.unlock();  // 必须手动写，忘了就死锁
}

// Kotlin 的 use 扩展函数就是 RAII 思想
FileOutputStream(path).use { stream ->
    stream.write(data)
}  // use 保证 stream.close() 一定执行

std::lock_guard<std::mutex> lock(mutex);  // "怎么创建了个 lock 但从没用它？"
                                            // 答：它不需要被"用"，它的存在就是目的

const user = { name: "Tom" };
user.name = "Jerry";   // ✅ 可以！const 只是不能重新赋值变量
user = { name: "X" };  // ❌ 不能重新赋值

const User user{"Tom"};
user.name = "Jerry";   // ❌ 编译错误！对象的内容也不能改

// ① 不加 const：拷贝一份，随便改（不影响原对象）
void Func1(std::string name) { name += "!"; }

// ② const 引用：不拷贝，不能改（只读访问，最常用）
void Func2(const std::string& name) { /* 只能读 name */ }

// ③ 非 const 引用：不拷贝，可以改（修改会反映到原对象）
void Func3(std::string& name) { name += "!"; /* 外面的也变了 */ }

class User {
    std::string name;
public:
    // 方法后面的 const 表示"这个方法承诺不修改任何成员变量"
    std::string GetName() const { return name; }

    // 没有 const 的方法可能会修改成员变量
    void SetName(const std::string& n) { name = n; }
};

源文件 ──→ 编译器/打包器一次性处理所有文件 ──→ 产物

每个 .cpp 文件独立编译 ──→ 各自生成 .o 文件 ──→ 链接器合并成最终产物

B.h（声明）："我有一个 Name() 方法，返回 string"
B.cpp（实现）："Name() 方法的具体代码是 return name_;"
A.cpp：#include "B.h"，编译器知道 B 有 Name() 方法就够了

// user.d.ts —— 相当于 C++ 的 .h
declare class User {
    name: string;
    getName(): string;
    setName(name: string): void;
}

// user.ts —— 相当于 C++ 的 .cpp
class User {
    name: string;
    getName(): string { return this.name; }
    setName(name: string): void { this.name = name; }
}

#include "User.h"

#ifndef USER_H        // 如果还没定义过 USER_H
#define USER_H        // 定义 USER_H（标记已经包含过了）

class User { ... };

#endif                // 结束

std::vector<int> a = {1, 2, 3, 4, 5};  // a 拥有这块数据
std::vector<int> b = std::move(a);       // 把数据"搬"给 b
// 现在 b = {1, 2, 3, 4, 5}
// 而 a = {}（被搬空了）

// 1. 显式 std::move
auto b = std::move(a);

// 2. 返回局部变量（编译器自动优化）
std::vector<int> CreateList() {
    std::vector<int> result = {1, 2, 3};
    return result;  // 编译器自动 move，不会拷贝
}

// 3. 传递临时对象
ProcessList(std::vector<int>{1, 2, 3});  // 临时对象自动 move

// JS 中的 Transferable（如 ArrayBuffer）
const buffer = new ArrayBuffer(1024);
worker.postMessage(buffer, [buffer]);  // transfer 后 buffer 变成 detached
buffer.byteLength;  // 0 —— 被"搬走"了

// C++ 模板
template <typename T>
T Max(T a, T b) {
    return (a > b) ? a : b;
}

Max(3, 5);         // T = int
Max(3.14, 2.71);   // T = double

// TypeScript 泛型 —— 概念完全一致
function max<T>(a: T, b: T): T {
    return a > b ? a : b;
}

// Kotlin 泛型
fun <T : Comparable<T>> max(a: T, b: T): T {
    return if (a > b) a else b
}

std::shared_ptr<TreeNode>              // 类比 TS: SharedPtr<TreeNode>
std::vector<std::string>               // 类比 TS: Array<string>
std::unordered_map<int, std::string>   // 类比 TS: Map<number, string>
std::function<void(int)>               // 类比 TS: (n: number) => void

// C++
namespace TurboDisplay {
    constexpr int kMaxDepth = 100;
    void Init();
}

// 使用
TurboDisplay::Init();
int max = TurboDisplay::kMaxDepth;

// TypeScript 最接近的对应
namespace TurboDisplay {
    export const kMaxDepth = 100;
    export function init(): void {}
}

TurboDisplay.init();

// Kotlin — 用 object 模拟
object TurboDisplay {
    const val K_MAX_DEPTH = 100
    fun init() {}
}

// JS 主线程是单线程的，"并发"靠事件循环
setTimeout(() => console.log("second"), 0);
console.log("first");
// 输出：first, second（setTimeout 排队到下一个事件循环）

// C++ 中多个线程是真正同时执行的，共享内存
int counter = 0;

// 线程 A
void ThreadA() { counter++; }

// 线程 B
void ThreadB() { counter++; }

// 两个线程同时执行，counter 最终可能是 1 而不是 2！
// 因为 counter++ 不是原子操作（读→加→写 三步，可能被打断）

std::mutex mtx;
void SafeIncrement() {
    std::lock_guard<std::mutex> lock(mtx);  // 进入前加锁
    counter++;                               // 同一时间只有一个线程能执行到这里
}                                            // 离开时自动解锁（RAII）

// 子线程执行耗时操作
std::thread worker([]() {
    auto data = LoadFromDisk();  // 耗时
});

// 主线程继续做 UI
UpdateUI();