如何用Boost Variant结合using声明实现递归树形数据结构？

你遇到的这个问题其实是C++递归类型定义的经典坑——typedef/using没法直接引用还没完全定义的类型，直接写InnerNode = std::unordered_map<std::string, boost::variant<InnerNode, LeafNode>>肯定会失败，因为定义InnerNode的时候，它自己还没完全成型呢。而用boost::make_recursive_variant时如果姿势不对，又会生成嵌套的变体类型，完全不是你想要的单一variant结构。

下面给你两种正确的实现方式，都能得到你想要的boost::variant<InnerNode, LeafNode>这种单一变体结构：

方法一：用boost::recursive_wrapper显式包装 #

这种方式更直观，先向前声明类型，再用递归包装器延迟类型实例化：

#include <boost/variant.hpp>
#include <unordered_map>
#include <string>

using LeafData = int;
using LeafNode = std::unordered_map<std::string, LeafData>;

// 先向前声明InnerNode，让Variant知道这个类型存在
struct InnerNode;

// 定义核心的变体类型：用recursive_wrapper包装还未完全定义的InnerNode
using NodeVariant = boost::variant<
    boost::recursive_wrapper<InnerNode>,
    LeafNode
>;

// 现在可以完整定义InnerNode了，它的值类型是我们刚定义的NodeVariant
using InnerNode = std::unordered_map<std::string, NodeVariant>;

boost::recursive_wrapper的作用就是“占位”——它告诉Boost Variant：“这个类型现在还没完全定义，等后面它成型了再处理”，完美解决了递归类型的定义依赖问题。

方法二：用boost::make_recursive_variant和占位符 #

如果你更习惯用make_recursive_variant，记得用boost::recursive_variant_作为递归占位符，这样生成的就是单一变体类型：

#include <boost/variant.hpp>
#include <unordered_map>
#include <string>

using LeafData = int;
using LeafNode = std::unordered_map<std::string, LeafData>;

// 用recursive_variant_作为递归引用的占位符，生成正确的变体类型
using NodeVariant = typename boost::make_recursive_variant<
    std::unordered_map<std::string, boost::recursive_variant_>,
    LeafNode
>::type;

// 把InnerNode定义为map到NodeVariant的类型
using InnerNode = std::unordered_map<std::string, NodeVariant>;

这里的boost::recursive_variant_就代表“我自己这个变体类型”，make_recursive_variant会自动把它替换成最终的变体类型，不会生成嵌套的结构。

验证一下使用方式 #

你可以用访客模式来遍历这个树形结构，比如：

#include <iostream>

struct NodeVisitor : boost::static_visitor<void> {
    void operator()(const LeafNode& leaf) const {
        for (const auto& [key, val] : leaf) {
            std::cout << "├─ Leaf: " << key << " = " << val << "\n";
        }
    }

    void operator()(const InnerNode& inner) const {
        for (const auto& [key, node] : inner) {
            std::cout << "├─ Inner node: " << key << "\n";
            // 递归访问子节点
            boost::apply_visitor(NodeVisitor{}, node);
        }
    }
};

int main() {
    // 构建一个简单的树形结构
    LeafNode leaf = {{"age", 30}, {"score", 95}};
    InnerNode root;
    root["user_info"] = leaf;

    InnerNode nested_inner;
    nested_inner["product_price"] = LeafNode{{"book", 59}, {"pen", 12}};
    root["shopping_cart"] = nested_inner;

    // 遍历输出
    boost::apply_visitor(NodeVisitor{}, root["user_info"]);
    boost::apply_visitor(NodeVisitor{}, root["shopping_cart"]);

    return 0;
}

这样运行后就能正确遍历树形结构，而且NodeVariant完全是你想要的单一变体类型，没有嵌套问题。

内容的提问来源于stack exchange，提问作者rkemp