我遇到的问题类似于此处描述的问题: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 header 。我尝试了 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;
}

最佳答案

你可以 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 和私有(private)访问者实现的控制流的简化。

#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

关于C++ 相互递归变体类型(再次)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/45803729/