我遇到的问题类似于此处描述的问题: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>;
现场演示
如您所见,代码中有未实现的部分(切勿编写缺少返回语句的函数!)。另请注意 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/