C++ 相互递归变体类型（再次）

Question

我遇到了与此处所述类似的问题：C++ Mutually Recursive Variant Type

我正在尝试在 C++ 中创建 JSON 表示。许多库已经提供了 优秀 JSON 表示和非常快的解析器，但我并没有重新发明这个轮子。我需要创建一个在特定条件下支持某些空间优化的 C++ JSON 表示。简而言之，当且仅当 JSON 数组包含同质数据，而不是将每个元素存储为臃肿的变体类型时，我才需要压缩存储原生类型。我还需要支持异构数组和标准的嵌套 JSON 对象。

以下是代码的“如果愿望是马，乞丐会骑”版本的代码，旨在清楚地说明意图，但由于在任何声明存在之前就使用了类型，因此显然被破坏了。我想避免在类型中多次指定相同的信息（即数组、对象和值不应该需要重复的类型规范）。我还想避免任何不必要的高运行时成本。

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

class JSONDocument {
    public:
        using String = std::string;
        using Integer = long;
        using Float = double;
        using Boolean = bool;
        using Null = void *;
        using Key = std::string;
        using Path = std::string;
        using Value = boost::variant<
                Null,
                String,
                Integer,
                Float,
                Boolean,
                Object,
                Array
                >;
        using Object = std::unordered_map<Key,Value>;
        using Array = boost::variant<
                std::vector<Null>,
                std::vector<String>,
                std::vector<Integer>,
                std::vector<Float>,
                std::vector<Boolean>,
                std::vector<Value> >;
    private:
        Value root;
        class value_traversal_visitor : public boost::static_visitor<Value> {
            public:
                value_traversal_visitor( Path path ) : path(path) {}
                Value operator()( Null x ) const {
                    if( path.empty() ) {
                        return x;
                    }
                    // otherwise throw ...
                }
                Value operator()( String x ) const {
                    if( path.empty() ) {
                        return x;
                    }
                }
                ...
                // special handling for Array and Object types
            private:
                Path path;
        };
    public:
        Value get( Path path ) {
            return boost::apply_visitor( value_traversal_visitor( path ), root );
        }
        ...
};

如您所见，我包含了recursive_wrapper 标头。我尝试过各种 boost::make_recursive_variant 和 boost::recursive_wrapper 的调用，但我总是遇到编译器错误。我看不到C++ Mutually Recursive Variant Type 的答案如何解决这个问题，因为在每次尝试中，我都会遇到编译器错误（来自 gcc++ 5.3 和 LLVM/clang++ 3.8），这些错误几乎完全引用了 Boost，本质上归结为不可转换的类型或声明冲突或不存在。我会将我的一项尝试与特定的编译器错误消息一起放在这里，但我不知道要使用哪些尝试。

我希望有人可以让我走上正确的道路......

提前致谢！

编辑

只是在下面接受的答案的基础上，这里是类型及其用法的工作框架示例。

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

using String = std::string;
using Integer = long;
using Float = double;
using Boolean = bool;
using Key = std::string;

using Value = boost::make_recursive_variant<
        String,
        Integer,
        Float,
        Boolean,
        std::unordered_map<Key, boost::recursive_variant_>,
        boost::variant<std::vector<String>,std::vector<Integer>,std::vector<Float>,std::vector<Boolean>,std::vector<boost::recursive_variant_> >
        >::type;

using Object = std::unordered_map<Key, Value>;

using Array = boost::variant<std::vector<String>,std::vector<Integer>,std::vector<Float>,std::vector<Boolean>,std::vector<Value> >;

int main( int argc, char* argv[] ) {
    Value v;
    v = static_cast<Integer>( 7 );
    Object o;
    v = o;
    Array a = std::vector<Integer>( 3 );
    v = a;
    return 0;
}

Answer 1

你可以use recursive_variant_ placeholder with make_recursive_variant。

这里是要点：

using Value   = boost::make_recursive_variant<
    Null, 
    String, 
    Integer, 
    Float, 
    Boolean,
    std::unordered_map<Key, boost::recursive_variant_>, // Object
    std::vector<boost::recursive_variant_>              // Array
>::type;
using Object = std::unordered_map<Key, Value>;
using Array = boost::variant<Value>;

现场演示

Live On Coliru

如您所见，代码中有未实现的位（永远不要编写缺少返回语句的函数！）。还要注意 get 和私有访问者实现的控制流的简化。

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

class JSONDocument {
  public:
    struct Null { constexpr bool operator==(Null) const { return true; } };
    using String  = std::string;
    using Integer = long;
    using Float   = double;
    using Boolean = bool;
    using Key     = std::string;
    using Path    = std::string;
    using Value   = boost::make_recursive_variant<
        Null, 
        String, 
        Integer, 
        Float, 
        Boolean,
        std::unordered_map<Key, boost::recursive_variant_>, // Object
        std::vector<boost::recursive_variant_>              // Array
    >::type;
    using Object = std::unordered_map<Key, Value>;
    using Array = boost::variant<Value>;

  private:
    Value root;

    struct value_traversal_visitor {
        Path path;
        using result_type = Value;

        result_type operator()(Value const &x) const {
            if (path.empty()) {
                return x;
            }
            return boost::apply_visitor(*this, x);
        }

        result_type operator()(Null)           const { throw std::invalid_argument("null not addressable"); }
        result_type operator()(String const &) const { throw std::invalid_argument("string not addressable"); }

        // special handling for Array and Object types TODO
        template <typename T> result_type operator()(T &&) const { return Null{}; }
    };

  public:
    Value get(Path path) { return value_traversal_visitor{path}(root); }
};

int main() {}

注意事项

• 请注意，您不应将 void* 用于 Null，因为会出现各种不需要的隐式转换

• 请注意，您可能不应该使用unordered_map，因为

  • 一些 JSON 实现允许重复的属性名称
  • 一些 JSON 应用程序依赖于属性的顺序

另见https://github.com/sehe/spirit-v2-json/blob/master/json.hpp#L37

Answer 2

本身不是解决方案，但这是一种使用 std::variant 实现变体递归的方法。我认为这可能很有趣，因为 stl 没有为递归或前向声明的类型提供任何 api。使用gcc 7.2 -std=c++17编译

#include <variant>
#include <vector>
#include <iostream>
#include <algorithm>

using namespace std;

struct Nil {};

struct vector1;

using var_t1 = variant<Nil, int, vector1>;
using var_t2 = variant<Nil, double, float, int, var_t1>;

struct vector1 { 
    vector<var_t2> v_; 
};

struct print_var_t2;

struct print_var_t1 {
    void operator()(const vector1& v);
    void operator()(int) { cout << "int\n"; }
    void operator()(const Nil&) { cout  << "nil\n"; }
};

struct print_var_t2 {
    void operator()(const Nil&) { cout << "Nil\n"; } 
    void operator()(int)  { cout << "int\n"; }
    void operator()(double) { cout << "double\n"; }
    void operator()(float)  { cout << "float\n"; }
    void operator()(const var_t1& v);
};

void print_var_t1::operator()(const vector1& v) {
    for_each(v.v_.begin(), v.v_.end(), [](const var_t2& x)
    {
        visit(print_var_t2{}, x);
    });
}

void print_var_t2::operator()(const var_t1& v) {
    visit(print_var_t1{}, v);    
}

int main()
{
    vector1 v1;
    v1.v_.push_back(.1);
    v1.v_.push_back(2.f);
    v1.v_.push_back(3);
    v1.v_.push_back(var_t2{3});

    var_t1 var1 = v1;

    std::visit(print_var_t1{}, var1);
    return 0;
}