如何用boost::spirit::karma处理含自定义类的boost::variant及枚举？

一、自定义类导致编译失败的原因及解决 #

核心原因 #

Boost.Spirit.Karma仅内置支持基础类型、部分Boost类型的序列化逻辑，对于自定义类，没有默认的生成规则，编译器无法推断如何将类实例转换为输出序列，从而触发编译错误。

解决步骤 #

为自定义类编写Karma生成器规则，并将该规则整合到variant的生成器中，让Karma能识别variant中的自定义类型。

完整代码示例

#include <boost/spirit/include/karma.hpp>
#include <boost/variant.hpp>
#include <iostream>
#include <string>

namespace karma = boost::spirit::karma;

// 自定义类A
struct A {
    int id;
    double value;
};

// 为A定义Karma生成器规则
template <typename OutputIterator>
struct AGenerator : karma::grammar<OutputIterator, A()> {
    AGenerator() : AGenerator::base_type(start) {
        // 定义类A的输出格式：A(整数, 浮点数)
        start = "A(" << karma::int_ << ", " << karma::double_ << ")";
    }
    karma::rule<OutputIterator, A()> start;
};

// 定义包含int、double、A的variant类型
using MyVariant = boost::variant<int, double, A>;

// 为variant整合所有类型的生成规则
template <typename OutputIterator>
struct VariantGenerator : karma::grammar<OutputIterator, MyVariant()> {
    VariantGenerator() : VariantGenerator::base_type(start) {
        // 依次匹配variant中的类型
        start = karma::int_ | karma::double_ | aRule;
    }
    AGenerator<OutputIterator> aRule;
    karma::rule<OutputIterator, MyVariant()> start;
};

int main() {
    MyVariant v1 = 42;
    MyVariant v2 = 3.14;
    MyVariant v3 = {100, 2.718};

    std::string output;
    std::back_insert_iterator<std::string> sink(output);
    VariantGenerator<std::back_insert_iterator<std::string>> generator;

    // 生成int类型输出
    output.clear();
    karma::generate(sink, generator, v1);
    std::cout << output << "\n"; // 输出：42

    // 生成double类型输出
    output.clear();
    karma::generate(sink, generator, v2);
    std::cout << output << "\n"; // 输出：3.14

    // 生成自定义类A的输出
    output.clear();
    karma::generate(sink, generator, v3);
    std::cout << output << "\n"; // 输出：A(100, 2.718)

    return 0;
}

二、枚举类型的Karma序列化方案 #

Karma不支持直接序列化枚举，需手动定义枚举值到输出格式的映射，以下两种常用方案：

方案1：映射枚举到字符串（输出枚举名称） #

通过karma::symbols将枚举值与对应的字符串关联，适合需要输出枚举名称的场景：

#include <boost/spirit/include/karma.hpp>
#include <iostream>
#include <string>

namespace karma = boost::spirit::karma;

enum class Color { Red, Green, Blue };

template <typename OutputIterator>
struct ColorGenerator : karma::grammar<OutputIterator, Color()> {
    ColorGenerator() : ColorGenerator::base_type(start) {
        // 绑定枚举值到字符串
        colorSymbols.add
            (Color::Red, "Red")
            (Color::Green, "Green")
            (Color::Blue, "Blue");
        start = colorSymbols;
    }
    karma::symbols<Color, const char*> colorSymbols;
    karma::rule<OutputIterator, Color()> start;
};

int main() {
    std::string output;
    std::back_insert_iterator<std::string> sink(output);
    ColorGenerator<std::back_insert_iterator<std::string>> colorGen;

    karma::generate(sink, colorGen, Color::Green);
    std::cout << output << "\n"; // 输出：Green
    return 0;
}

方案2：输出枚举的整数值 #

通过特化boost::spirit::traits::transform_attribute，让Karma自动将枚举转换为整数后输出：

#include <boost/spirit/include/karma.hpp>
#include <iostream>
#include <string>

namespace karma = boost::spirit::karma;

enum class Color { Red, Green, Blue };

// 特化转换逻辑，将Color枚举转为int
namespace boost { namespace spirit { namespace traits {
    template <>
    struct transform_attribute<Color, int, karma::domain> {
        static int pre(Color c) {
            return static_cast<int>(c);
        }
    };
}}}

int main() {
    std::string output;
    std::back_insert_iterator<std::string> sink(output);

    // 直接用int_生成器输出枚举的整数值
    karma::generate(sink, karma::int_, Color::Green);
    std::cout << output << "\n"; // 输出：1
    return 0;
}

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