第27章：模式匹配与访问者：std::visit模式、Lambda重载技巧

说实话，C++17 引入的 std::visit 是我近几年最喜欢的新特性之一。它让「模式匹配」这件事变得异常优雅。你想想看，以前我们要处理 std::variant 里的不同类型，得写一堆 if-else 加 std::get_if，代码又臭又长。现在？一个 std::visit 搞定。

但真正让我觉得惊艳的，是它和 Lambda 重载技巧结合后的威力。嗯，咱们今天就来聊聊这个。

std::visit 的基本用法

先看个最简单的例子。假设你有一个 std::variant<int, double, std::string>，想根据实际类型做不同处理：

#include <variant>
#include <iostream>
#include <string>

int main() {
    std::variant<int, double, std::string> v = 42;

    std::visit([](auto&& arg) {
        std::cout << arg << std::endl;
    }, v);

    return 0;
}

这里用了泛型 Lambda，所有类型共享同一套处理逻辑。但问题来了——如果我想对不同类型做不同操作呢？

Lambda 重载技巧：overloaded 模式

我在项目中遇到过这样一个场景：需要根据 variant 里的类型执行完全不同的逻辑。比如 int 就做加法，double 就做格式化，string 就做拼接。这时候泛型 Lambda 就不够用了。

解决方案？用「Lambda 重载」技巧。说白了，就是利用继承和 using 声明，把多个 Lambda 合并成一个重载集：

template<class... Ts>
struct overloaded : Ts... {
    using Ts::operator()...;
};

// C++17 的推导指引
template<class... Ts>
overloaded(Ts...) -> overloaded<Ts...>;

int main() {
    std::variant<int, double, std::string> v = 3.14;

    std::visit(
        overloaded{
            [](int arg) { std::cout << "整数: " << arg * 2 << "\n"; },
            [](double arg) { std::cout << "浮点数: " << arg + 0.5 << "\n"; },
            [](const std::string& arg) { std::cout << "字符串: " << arg + "!" << "\n"; }
        },
        v
    );

    return 0;
}

你看，每个类型对应一个 Lambda，清晰又直观。而且编译器会在编译期帮你检查——如果某个类型没被覆盖，编译直接报错。这比运行时 if-else 安全多了。

实战：表达式求值器

让我给你展示一个更实际的例子。假设你在写一个简单的表达式求值器，用 variant 表示 AST 节点：

struct Number { double value; };
struct Add { std::shared_ptr<Node> left, right; };
struct Mul { std::shared_ptr<Node> left, right; };

using Node = std::variant<Number, Add, Mul>;

double eval(const Node& node) {
    return std::visit(
        overloaded{
            [](const Number& n) { return n.value; },
            [](const Add& a) { return eval(*a.left) + eval(*a.right); },
            [](const Mul& m) { return eval(*m.left) * eval(*m.right); }
        },
        node
    );
}

这个例子我特别喜欢。它把「模式匹配」和「递归」结合在了一起。每个节点类型只关心自己的处理逻辑，递归调用交给 std::visit 自动完成。

我曾经在一个编译器项目里用这个模式处理了 20 多种 AST 节点类型。代码量比传统的访问者模式少了至少一半，而且更容易维护。

避坑指南：我踩过的几个坑

嗯，这里得说说我踩过的坑，希望能帮你省点时间。

进阶：与 std::optional 和 std::expected 配合

你想想看，如果 std::visit 返回一个 std::optional 或者 std::expected，那组合起来会非常强大。比如：

std::optional<double> try_eval(const Node& node) {
    return std::visit(
        overloaded{
            [](const Number& n) -> std::optional<double> { return n.value; },
            [](const Add& a) -> std::optional<double> {
                auto l = try_eval(*a.left);
                auto r = try_eval(*a.right);
                if (!l || !r) return std::nullopt;
                return *l + *r;
            },
            [](const Mul& m) -> std::optional<double> {
                auto l = try_eval(*m.left);
                auto r = try_eval(*m.right);
                if (!l || !r) return std::nullopt;
                return *l * *r;
            }
        },
        node
    );
}

这样，如果某个子节点求值失败，整个表达式会优雅地返回 nullopt，而不是抛异常或者崩溃。

知识体系总览

下面这张图帮你理清本章的核心逻辑：

总结一下

说白了，std::visit 加上 Lambda 重载技巧，就是 C++17 给我们的「模式匹配」利器。它让代码更简洁、更安全、更容易维护。我个人觉得，这是现代 C++ 里最值得掌握的特性之一。

如果你还在用 if-else 处理 variant，我建议你试试这个方案。刚开始可能有点不习惯，但用上几次你就会爱上它。嗯，至少我是这样的。

---

公众号:蓝海资料掘金营，微信deep3321