c++ - 实现 std::variant 转换构造函数 - 或者:如何从参数包中找到从任何 T 到 Ti 的所有转换的第一个重载

Question

在最新working draft (第 572 页)C++ 标准的转换构造函数 std::variant注释为:

template <class T> constexpr variant(T&& t) noexcept(see below );

Let Tj be a type that is determined as follows: build an imaginary function FUN (Ti) for each alternative type Ti. The overload FUN (Tj) selected by overload resolution for the expression FUN (std::forward<T>(t)) defines the alternative Tj which is the type of the contained value after construction.

Effects: Initializes *this to hold the alternative type Tj and direct-initializes the contained value as if direct-non-list-initializing it with std::forward<T>(t).

[...]

Remarks: This function shall not participate in overload resolution unless is_same_v<decay_t<T>, variant> is false, unless is_constructible_v<Tj, T> is true, and unless the expression FUN ( std::forward<T>(t)) (with FUN being the above-mentioned set of imaginary functions) is well formed.

关于 cppreference以下示例用于说明转换:

variant<string> v("abc"); // OK
variant<string, string> w("abc"); // ill-formed, can't select the alternative to convert to
variant<string, bool> x("abc"); // OK, but chooses bool

如何模仿虚构的重载决议以获得最终类型 Tj ？

Answer 1

我将描述的技术是实际构建一个重载集，并通过尝试调用它并查看 std::result_of 会发生什么来执行重载解析。 .

构建重载集

我们定义了一个函数对象，它递归地定义了一个 T operator()(T) const对于每个 T .

template <typename T>
struct identity { using type = T; };

template <typename... Ts> struct overload;

template <> struct overload<> { void operator()() const; };

template <typename T, typename... Ts>
struct overload<T, Ts...> : overload<Ts...> {
  using overload<Ts...>::operator();
  identity<T> operator()(T) const;
};

// void is a valid variant alternative, but "T operator()(T)" is ill-formed
// when T is void
template <typename... Ts>
struct overload<void, Ts...> : overload<Ts...> {
  using overload<Ts...>::operator();
  identity<void> operator()() const;
};

执行过载解析

我们现在可以使用 std::result_of_t模拟过载解决方案，并找到获胜者。

// Find the best match out of `Ts...` with `T` as the argument.
template <typename T, typename... Ts>
using best_match = typename std::result_of_t<overload<Ts...>(T)>::type;

在variant<Ts...>内，我们会像这样使用它:

template <typename T, typename U = best_match<T&&, Ts...>>
constexpr variant(T&&);

一些测试

好的!我们完了吗？以下测试通过!

// (1) `variant<string, void> v("abc");` // OK
static_assert(
    std::is_same_v<std::string,
                   best_match<const char*, std::string, void>>);

// (2) `variant<string, string> w("abc");` // ill-formed
static_assert(
    std::is_same_v<std::string,
                   best_match<const char*, std::string, std::string>>);

// (3) `variant<string, bool> x("abc");` // OK, but chooses bool
static_assert(
    std::is_same_v<bool,
                   best_match<const char*, std::string, bool>>);

好吧，我们不想(2)通过，实际上。让我们再探讨几个案例:

没有可行的匹配

如果没有可行的匹配项，构造函数将简单地排除 SFINAE。我们在 best_match 中免费获得此行为，因为 std::result_of从 C++14 开始对 SFINAE 友好 :D

唯一匹配

我们希望最佳匹配是独一无二的最佳匹配。这是 (2)我们想失败。例如，我们可以通过检查 best_match 的结果来测试它在 Ts... 中恰好出现一次.

template <typename T, typename... Ts>
constexpr size_t count() {
  size_t result = 0;
  constexpr bool matches[] = {std::is_same_v<T, Ts>...};
  for (bool match : matches) {
    if (match) {
      ++result;
    }
  }
  return result;
}

然后我们可以将此条件扩充到 best_match 上以 SFINAE 友好的方式:

template <typename T, typename... Ts>
using best_match_impl = std::enable_if_t<(count<T, Ts...>() == 1), T>;

template <typename T, typename... Ts>
using best_match = best_match_impl<std::result_of_t<overload<Ts...>(T)>, Ts...>;

结论

(2)现在失败了，我们可以简单地使用 best_match像这样:

template <typename T, typename U = best_match<T&&, Ts...>>
constexpr variant(T&&);

更多测试

template <typename> print;  // undefined

template <typename... Ts>
class variant {
  template <typename T, typename U = best_match<T&&, Ts...>>
  constexpr variant(T&&) {
    print<U>{}; // trigger implicit instantiation of undefined template error.
  }
};

// error: implicit instantiation of undefined template
// 'print<std::__1::basic_string<char> >'
variant<std::string> v("abc");

// error: no matching constructor for initialization of
// 'variant<std::string, std::string>'
variant<std::string, std::string> w("abc");

// error: implicit instantiation of undefined template 'print<bool>'
variant<std::string, bool> x("abc");