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

C++ Mutually Recursive Variant Type (Again)

本文关键字：类型 再次 递归 C++      更新时间：2023-10-16

我有一个类似于这里描述的问题： C++ 相互递归变体类型

我正在尝试在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++相互递归变体类型的答案如何解决这个问题，因为在每次尝试中，我都会得到编译器错误(来自 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;
}

您可以将recursive_variant_占位符与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控制流和私人访客实现的简化。

#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() {}

警告

  • 请注意，您不应该对 Null 使用void*，因为各种不需要的隐式转换

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

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

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

本身不是解决方案，但 这是使用 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 << "intn"; }
void operator()(const Nil&) { cout  << "niln"; }
};
struct print_var_t2 {
void operator()(const Nil&) { cout << "Niln"; } 
void operator()(int)  { cout << "intn"; }
void operator()(double) { cout << "doublen"; }
void operator()(float)  { cout << "floatn"; }
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;
}
相关文章：