通过boost.Variant递归对，因为提升1.62

Question

我正在处理的代码使用递归对。在简化示例中，类型包含由string和int或另一个此类对组成的对。这应该（并且是）可以实现：

#include <boost/variant.hpp>
#include <string>

using namespace std;

typedef boost::make_recursive_variant
      < std::pair
        < std::string
        , boost::variant<int, boost::recursive_variant_>
        >
      >::type recursivePair;

typedef boost::variant< int
                    , recursivePair
                    > intPairVariant;

using sType = boost::variant<pair<string, string>, int>;

void foo(){
    sType bar(make_pair("aa", "bb"));
    recursivePair xxx(std::make_pair (std::string("s"), intPairVariant()));
    recursivePair yyy(std::make_pair (string("s"), 5));
    recursivePair zzz(std::make_pair ("s", 5));
}

sType表示该对中的隐式转化仍然适用。

然而，从Boost 1.62开始，这会在编译期间中断：

error: no matching function for call to ‘boost::variant<boost::detail::variant::recursive_flag<std::pair<std::__cxx11::basic_string<char>, boost::variant<int, boost::recursive_variant_> > > >::variant(std::pair<std::__cxx11::basic_string<char>, int>)’
     recursivePair yyy(std::make_pair (string("s"), 5));

这仅适用于一种类型。其他人也失败了。

有谁知道为什么这不再起作用以及如何解决这个问题？

Answer 1

我认为你实际上遇到了std::pair<>的类似变化：does boost-1.55 boost::property_tree::ptree compile with c++11?

自c ++ 11以来，std :: pair的隐式转换次数较少。你的代码确实编译了boost＆lt; 1.62但是，实际上看起来这是一个错误，至少在c ++ 11模式下。

在C ++ 11中，你这样做：

std::make_pair(s, i); // s is std::string, i is int

会产生std::pair<std::string, int>。接下来，您不仅要求隐式转换std::pair<std::string, int>到std::pair<std::string, IntPairVariant>，而且您希望使用转换的结果作为变体的初始化程序''重新分配。

在C ++的所有部分中，都要求进行两次隐式转换，编译器永远不会使用它来解决重载。

所以，实际上你的代码有点草率，因为它使用了Boost Variant应该没有的“余地”。 是突然改变，但新行为似乎更有意义。

另一个注意事项

您正在使用单个元素制作递归变体。那......有点奇怪。

通过将std::pair<>结构属性隐藏在variant的第一层下，这会使类型系统“紧张”一点。

直接使用A std::pair

<强> Live On Coliru

我能想象的最无聊的事情：

#include <boost/variant.hpp>
#include <string>

using namespace std;

typedef std::pair<std::string,
    boost::make_recursive_variant<int, std::pair<std::string, boost::recursive_variant_> >::type >
    recursivePair;

typedef boost::variant<int, recursivePair> intPairVariant;

int main() {
    recursivePair xxx(std::string("s"), intPairVariant());
    recursivePair yyy(string("s"), 5);
    recursivePair zzz("s", 5);
}

注意这已经允许你问题中的确切拼写：

recursivePair xxx(std::make_pair(std::string("s"), intPairVariant()));
recursivePair yyy(std::make_pair(string("s"), 5));
recursivePair zzz(std::make_pair("s", 5));

但make_pair在所有三种情况下都是多余的。

有趣的变化

也许你可以做更像

的事情

struct V;
using Pair = std::pair<std::string, V>;

struct V : boost::variant<int, boost::recursive_wrapper<Pair> > {
    using base = boost::variant<int, boost::recursive_wrapper<Pair> >;
    using base::base;
    using base::operator=;
};

现在你可以安全地说

<强> Live On Coliru

Pair xxx("s", V{});
Pair yyy("s", 5);
Pair zzz{};

帮助构造函数

使用派生结构而不是普通变体的好处是你实际上可以消除构造函数的歧义：

<强> Live On Coliru

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

namespace mylib {

    struct V;
    using Pair = std::pair<std::string, V>;

    struct V : boost::variant<int, boost::recursive_wrapper<Pair> > {
        using base = boost::variant<int, boost::recursive_wrapper<Pair> >;

        V() = default;
        V(V&&) = default;
        V(V const&) = default;
        V& operator=(V&&) = default;
        V& operator=(V const&) = default;

        V(int i) : base(i) {}
        V(std::string const& key, V value);
    };

    V::V(std::string const& key, V value) : base{Pair{std::move(key), std::move(value)}} {}

    static inline std::ostream& operator<<(std::ostream& os, Pair const& p) {
        return os << "{" << p.first << "," << p.second << "}";
    }
}

int main() {
    using mylib::V;
    V xxx("s", mylib::V{});
    V yyy("s", 5);
    V zzz{};
    V huh("s", {"more", {"intricate", {"nested", { "truths", 42} } } });

    V simple = 5;
    simple = {"simple", 5};
    simple = {"not_so_simple", simple};

    std::cout << "xxx:" << xxx << "\n";
    std::cout << "yyy:" << yyy << "\n";
    std::cout << "zzz:" << zzz << "\n";
    std::cout << "huh:" << huh << "\n";
    std::cout << "simple:" << simple << "\n";
}

打印

xxx:{s,0}
yyy:{s,5}
zzz:0
huh:{s,{more,{intricate,{nested,{truths,42}}}}}
simple:{not_so_simple,{simple,5}}