前端开发者快速掌握 C++：从 JS/Kotlin 到 C++ 的思维跨越

// JS — 创建完就忘，GC 帮你收拾
function createUser() {
    const user = { name: "Tom", age: 25 };
    return user;  // 用完了 GC 自动回收
}

// C++ — 你必须为每个对象安排归宿
User* user = new User("Tom", 25);   // 你创建了它
// ... 使用 user ...
delete user;                          // 你必须销毁它，否则内存泄漏

// C++
#include <memory>
auto node = std::make_shared<TreeNode>(1, "Button");
auto alias = node;  // 引用计数 +1，两个变量指向同一个对象
// 当 node 和 alias 都离开作用域时，对象才被销毁

// JS 等价 — 你从来不需要想这些，GC 自动处理
const node = new TreeNode(1, "Button");
const alias = node;

// Kotlin 等价
val node = TreeNode(1, "Button")
val alias = node

// C++
auto cache = std::make_unique<CacheData>();
// auto copy = cache;           // ❌ 编译错误！unique_ptr 不能拷贝
auto moved = std::move(cache);  // ✅ 所有权转移，cache 变成 nullptr

// C++
std::weak_ptr<RenderView> view_ref;  // 弱引用，不阻止对象销毁
if (auto view = view_ref.lock()) {    // 尝试获取强引用
    view->Render();                    // 成功：对象还活着
}
// 失败：对象已被销毁，lock() 返回 nullptr

// Kotlin
val viewRef = WeakReference(renderView)
viewRef.get()?.render()  // 对象被回收了就返回 null

// JS — WeakRef (ES2021)
const viewRef = new WeakRef(renderView);
viewRef.deref()?.render();

// C++
std::optional<int> parentId;           // 没有值
parentId = 42;                          // 有值
if (parentId.has_value()) {
    int id = parentId.value();          // 取值
}
parentId = std::nullopt;                // 置空

// Kotlin
var parentId: Int? = null
parentId = 42
parentId?.let { id -> /* 使用 id */ }
parentId = null

// JS
let parentId = undefined;
parentId = 42;
if (parentId !== undefined) { /* 使用 parentId */ }
parentId = undefined;

// TreeNode.h — 头文件（声明）："我长什么样"
class TreeNode {
public:
    int tag;
    std::string name;
    void AddChild(std::shared_ptr<TreeNode> child, int index);
private:
    std::shared_ptr<Prop> FindProp(const std::string& key) const;
};

// TreeNode.cpp — 源文件（实现）："我怎么工作"
void TreeNode::AddChild(std::shared_ptr<TreeNode> child, int index) {
    children.insert(children.begin() + index, child);
    child->parentTag = tag;
}

// Kotlin — 一个文件搞定
class TreeNode(var tag: Int, var name: String) {
    fun addChild(child: TreeNode, index: Int) {
        children.add(index, child)
        child.parentTag = tag
    }
    private fun findProp(key: String): Prop? { ... }
}

void Process(const std::string& name);    // const 引用
void Modify(std::string& name);           // 可变引用
void Consume(std::string&& name);         // 右值引用（移动语义）

// JS 开发者理解：
// JS 中对象天然是引用传递，基本类型是值传递
// C++ 默认全是值传递（拷贝），加 & 才是引用传递

// C++
auto callback = [this, count](const std::string& msg) {
    std::cout << name << ": " << msg << " (" << count << ")" << std::endl;
};

// JS — 自动捕获，不需要声明
const callback = (msg) => {
    console.log(`${this.name}: ${msg} (${count})`);
};

// Kotlin — 也是自动捕获
val callback = { msg: String ->
    println("${name}: $msg ($count)")
}

// C++ vector
std::vector<int> nums;
nums.push_back(42);                        // JS: nums.push(42)
nums.insert(nums.begin() + 2, 99);         // JS: nums.splice(2, 0, 99)
nums.erase(nums.begin() + 2);              // JS: nums.splice(2, 1)
nums.size();                               // JS: nums.length
nums.empty();                              // JS: nums.length === 0
nums.reserve(100);                         // JS: 无对应，引擎自动管理

// C++ unordered_map
std::unordered_map<std::string, int> ages;
ages["Tom"] = 25;                          // JS: ages["Tom"] = 25 或 ages.set("Tom", 25)
auto it = ages.find("Tom");                // JS: ages.has("Tom")
if (it != ages.end()) {
    int age = it->second;                  // JS: ages.get("Tom")
}
ages.erase("Tom");                         // JS: ages.delete("Tom") 或 delete ages["Tom"]

// C++ — auto 推导
auto node = std::make_shared<TreeNode>(1, "Button");   // 类型: shared_ptr<TreeNode>
auto it = nodeMap.find(tag);                            // 类型: unordered_map<...>::iterator
auto [updated, hasWatch] = DiffTrees(oldTree, newTree); // C++17 解构绑定

// JS — 天生弱类型
const node = new TreeNode(1, "Button");
const entry = nodeMap.get(tag);
const [updated, hasWatch] = diffTrees(oldTree, newTree);

// Kotlin — 类型推导
val node = TreeNode(1, "Button")
val entry = nodeMap[tag]
val (updated, hasWatch) = diffTrees(oldTree, newTree)

// C++ 接口（纯虚类）
class IRenderLayer {
public:
    virtual void CreateView(int tag, const std::string& name) = 0;  // = 0 纯虚
    virtual void Destroy() = 0;
    virtual ~IRenderLayer() = default;  // 虚析构函数（接口必备）
};

// C++ 实现
class ProxyRenderLayer : public IRenderLayer {
    void CreateView(int tag, const std::string& name) override { ... }
    void Destroy() override { ... }
};

// Kotlin
interface IRenderLayer {
    fun createView(tag: Int, name: String)
    fun destroy()
}

class ProxyRenderLayer : IRenderLayer {
    override fun createView(tag: Int, name: String) { ... }
    override fun destroy() { ... }
}

// JS — 没有接口，靠鸭子类型
class ProxyRenderLayer {
    createView(tag, name) { ... }
    destroy() { ... }
}

// C++
try {
    auto node = Deserialize(data, offset);
} catch (const std::exception& e) {
    // e.what() 获取错误信息
    return nullptr;
} catch (...) {
    // 捕获所有异常（包括非标准异常）
    return nullptr;
}

// Kotlin
try {
    val node = deserialize(data, offset)
} catch (e: Exception) {
    return null
}

// JS
try {
    const node = deserialize(data, offset);
} catch (e) {
    return null;
}

// C++ — RAII 锁（作用域结束自动解锁）
std::mutex mutex;
void WriteFile(const std::vector<uint8_t>& data) {
    std::lock_guard<std::mutex> lock(mutex);
    // ... 线程安全操作 ...
}  // ← lock 离开作用域，自动解锁

// Kotlin
private val mutex = Any()
fun writeFile(data: ByteArray) {
    synchronized(mutex) {
        // ... 线程安全操作 ...
    }
}

// JS — 单线程模型，通常不需要锁
// Web Worker 间通过 postMessage 通信，无共享内存

// C++
class CacheManager {
    static std::mutex fileMutex;  // 所有实例共享一把锁
    static std::string BuildCacheKey(const std::string& page, const std::string& key);
};

// .cpp 中定义（static 成员必须在类外定义一次）
std::mutex CacheManager::fileMutex;

// Kotlin
class CacheManager {
    companion object {
        private val fileMutex = Mutex()
        fun buildCacheKey(page: String, key: String): String { ... }
    }
}

// JS
class CacheManager {
    static fileMutex = new Mutex(); // 提案 stage 3
    static buildCacheKey(page, key) { ... }
}

// C++ — 冒号后面的部分是"初始化列表"
ProxyRenderLayer::ProxyRenderLayer()
    : realLayer(std::make_shared<RenderLayer>()),
      rootNode(std::make_shared<TreeNode>(-1, "Root")) {
    // 构造函数体（可选的额外逻辑）
}

// Kotlin — 直接在属性声明时初始化
class ProxyRenderLayer {
    private val realLayer = RenderLayer()
    private val rootNode = TreeNode(-1, "Root")
}

// C++17 variant — 类型安全的联合体
std::variant<
    std::monostate,                     // 空状态
    std::shared_ptr<Value>,             // 普通值
    std::function<void(Result)>,        // 回调函数
    std::shared_ptr<ShadowNode>         // 布局节点
> propValue;

// 类型判断
if (std::holds_alternative<std::shared_ptr<Value>>(propValue)) {
    auto val = std::get<std::shared_ptr<Value>>(propValue);
}

// Kotlin sealed class
sealed class PropValue {
    object Empty : PropValue()
    data class AnyValue(val value: Value) : PropValue()
    data class Callback(val fn: (Result) -> Unit) : PropValue()
    data class Shadow(val node: ShadowNode) : PropValue()
}

when (propValue) {
    is PropValue.AnyValue -> { val v = propValue.value }
    ...
}

// TypeScript 联合类型
type PropValue =
    | { type: "empty" }
    | { type: "value"; value: Value }
    | { type: "callback"; fn: (result: Result) => void }
    | { type: "shadow"; node: ShadowNode };