如何用 std::variant 正确替换 boost::variant？

Question

使用boost:variant：

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

template <size_t n, typename... T>
boost::variant<T...> _tuple_index(size_t i, const std::tuple<T...>& tpl) {
    if (i == n)
        return std::get<n>(tpl);
    else if (n == sizeof...(T) - 1)
        throw std::out_of_range("Out of Index");
    else
        return _tuple_index<(n < sizeof...(T)-1 ? n+1 : 0)>(i, tpl);
}
template <typename... T>
boost::variant<T...> tuple_index(size_t i, const std::tuple<T...>& tpl) {
    return _tuple_index<0>(i, tpl);
}

template <typename T>
auto tuple_len(T &tpl) {
    return std::tuple_size<T>::value;
}

int main()
{
    std::tuple<std::string, double, double, int> t("123", 4.5, 6.7, 8);
    for(int i = 0; i != tuple_len(t); ++i) {
        std::cout << tuple_index(i, t) << std::endl; // works with boost
    }
}

替换boost::variant为std::variant，向流添加了一个助手std::variant：

#include <tuple>
#include <iostream>
#include <variant>

template <size_t n, typename... T>
std::variant<T...> _tuple_index(size_t i, const std::tuple<T...>& tpl) {
    if (i == n)
        return std::get<n>(tpl);
    else if (n == sizeof...(T) - 1)
        throw std::out_of_range("Out of Index");
    else
        return _tuple_index<(n < sizeof...(T)-1 ? n+1 : 0)>(i, tpl);
}
template <typename... T>
std::variant<T...> tuple_index(size_t i, const std::tuple<T...>& tpl) {
    return _tuple_index<0>(i, tpl);
}

template <typename T>
auto tuple_len(T &tpl) {
    return std::tuple_size<T>::value;
}

// added helper to stream std::variant
template <typename T0, typename ... Ts>
std::ostream & operator<< (std::ostream & s, std::variant<T0, Ts...> const & v) { 
    std::visit([&](auto && arg){ s << arg;}, v); 
    return s;
}

int main()
{
    std::tuple<std::string, double, double, int> t("123", 4.5, 6.7, 8);
    for(int i = 0; i != tuple_len(t); ++i) {
        std::cout << tuple_index(i, t) << std::endl; // doesn't work anymore
    }
}

编译依然报错：

$ clang++ -v                                                                                                                                                                                                                                                            [17:37:47]
Apple LLVM version 10.0.1 (clang-1001.0.46.4)
Target: x86_64-apple-darwin18.6.0
Thread model: posix
InstalledDir: /Library/Developer/CommandLineTools/usr/bin

$ clang++ -std=c++17 isostd.cpp

isostd.cpp:8:16: error: no viable conversion from returned value of type 'const typename tuple_element<1UL, tuple<basic_string<char>, double, double, int> >::type' (aka 'const __type_pack_element<1UL, std::__1::basic_string<char>, double, double, int>') to function return
      type 'std::variant<basic_string<char>, double, double, int>'
        return std::get<n>(tpl);
               ^~~~~~~~~~~~~~~~
isostd.cpp:12:16: note: in instantiation of function template specialization '_tuple_index<1, std::__1::basic_string<char>, double, double, int>' requested here
        return _tuple_index<(n < sizeof...(T)-1 ? n+1 : 0)>(i, tpl);
               ^
isostd.cpp:16:12: note: in instantiation of function template specialization '_tuple_index<0, std::__1::basic_string<char>, double, double, int>' requested here
    return _tuple_index<0>(i, tpl);
           ^
isostd.cpp:35:22: note: in instantiation of function template specialization 'tuple_index<std::__1::basic_string<char>, double, double, int>' requested here
        std::cout << tuple_index(i, t) << std::endl; // doesn't work anymore
                     ^
/Library/Developer/CommandLineTools/usr/include/c++/v1/variant:1142:3: note: candidate constructor not viable: no known conversion from 'const typename tuple_element<1UL, tuple<basic_string<char>, double, double, int> >::type'
      (aka 'const __type_pack_element<1UL, std::__1::basic_string<char>, double, double, int>') to 'const std::__1::variant<std::__1::basic_string<char>, double, double, int> &' for 1st argument
  variant(const variant&) = default;
  ^
/Library/Developer/CommandLineTools/usr/include/c++/v1/variant:1143:3: note: candidate constructor not viable: no known conversion from 'const typename tuple_element<1UL, tuple<basic_string<char>, double, double, int> >::type'
      (aka 'const __type_pack_element<1UL, std::__1::basic_string<char>, double, double, int>') to 'std::__1::variant<std::__1::basic_string<char>, double, double, int> &&' for 1st argument
  variant(variant&&) = default;
  ^
/Library/Developer/CommandLineTools/usr/include/c++/v1/variant:1155:13: note: candidate template ignored: substitution failure [with _Arg = const double &, $1 = 0, $2 = 0, $3 = 0, _Tp = double]: no member named 'value' in
      'std::__1::__find_detail::__find_unambiguous_index_sfinae<double, std::__1::basic_string<char>, double, double, int>'
  constexpr variant(_Arg&& __arg) noexcept(
            ^
1 error generated.

如何用 std::variant 正确替换 boost:variant？

我知道参考：std::variant 和 boost::variant 之间有什么区别？

Boost.Variant 包括 recursive_variant，它允许变体包含自身。它们本质上是围绕指向 boost::variant 的指针的特殊包装器，但它们与访问机制相关联。

如果我理解正确，有没有办法完成替换？

Answer 1

由于您的变体中有重复的类型，因此一些构造函数被禁用：

如果在 Types... 中恰好出现了一次 T，则此重载仅参与重载决议。

您需要使用具有显式类型索引的构造函数：

return std::variant<T...>(std::in_place_index<n>, std::get<n>(tpl));

您的原始提升代码具有未定义的行为：

在移除限定符后，指定为变体的模板参数的每种类型都必须是不同的。因此，例如，variant<int, int>和variant<int, const int>都有未定义的行为。

标准的库实现确实支持重复类型，因此可以防止您意外构建歧义变体。例如，下面应该做什么：

variant<std::string, double, double, int> t = 4.5;

使用 boost 是 UB，其中一个double值可能会被初始化，或者它可能会做一些完全不同的事情。标准库明确地使这是一个编译器错误，因此您必须选择double要初始化的 s。