[variant.visit] (original) (raw)

22 General utilities library [utilities]

22.6 Variants [variant]

22.6.7 Visitation [variant.visit]

template<class Visitor, class... Variants> constexpr _see below_ visit(Visitor&& vis, Variants&&... vars);template<class R, class Visitor, class... Variants> constexpr R visit(Visitor&& vis, Variants&&... vars);

Let as-variant denote the following exposition-only function templates:template<class... Ts> constexpr auto&& as-variant(variant<Ts...>& var) { return var; } template<class... Ts> constexpr auto&& as-variant(const variant<Ts...>& var) { return var; } template<class... Ts> constexpr auto&& as-variant(variant<Ts...>&& var) { return std::move(var); } template<class... Ts> constexpr auto&& as-variant(const variant<Ts...>&& var) { return std::move(var); }

Let n be sizeof...(Variants).

For each , let denote the type
decltype(as-variant(std​::​forward<>())).

Constraints: is a valid type for all .

Let V denote the pack of types .

Let m be a pack of n values of type size_t.

Such a pack is valid if
for all .

For each valid pack m, let e(m) denote the expression:INVOKE(std::forward<Visitor>(vis), GET<m>(std::forward<V>(vars))...) for the first form and_INVOKE_<R>(std::forward<Visitor>(vis), GET<m>(std::forward<V>(vars))...) for the second form.

Mandates: For each valid pack m, e(m) is a valid expression.

All such expressions are of the same type and value category.

Returns: e(m), where m is the pack for which is as-variant(vars).index() for all .

The return type is decltype(e(m))for the first form.

Throws: bad_variant_access if(as-variant(vars).valueless_by_exception() || ...)is true.

Complexity: For n ≤ 1, the invocation of the callable object is implemented in constant time, i.e., for , it does not depend on the number of alternative types of .

For , the invocation of the callable object has no complexity requirements.

template<class Self, class Visitor> constexpr decltype(auto) visit(this Self&& self, Visitor&& vis);

Let V be_OVERRIDE_REF_(Self&&, COPY_CONST(remove_reference_t<Self>, variant)) ([forward]).

Effects: Equivalent to: return std​::​visit(std​::​forward<Visitor>(vis), (V)self);

template<class R, class Self, class Visitor> constexpr R visit(this Self&& self, Visitor&& vis);

Let V be_OVERRIDE_REF_(Self&&, COPY_CONST(remove_reference_t<Self>, variant)) ([forward]).

Effects: Equivalent to: return std​::​visit<R>(std​::​forward<Visitor>(vis), (V)self);