20 General utilities library [utilities]

20.7 Variants [variant]

20.7.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 n be sizeof...(Variants).

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

Such a pack is called valid if

0 \leq m_{i} < {variant_size_v<remove_reference_t<Variants}_{i} >>

for all

0 \leq i < n

For each valid pack m, let e(m) denote the expression:

INVOKE(std::forward<Visitor>(vis), get<m>(std::forward<Variants>(vars))...) // see [func.require]

for the first form and

INVOKE<R>(std::forward<Visitor>(vis), get<m>(std::forward<Variants>(vars))...) // see [func.require]

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

m_{i}

is vars

_{i}

.index() for all

0 \leq i < n

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

Throws: bad_variant_access if any variant in vars is valueless_by_exception().

Complexity: For

n \leq 1

, the invocation of the callable object is implemented in constant time, i.e., for

n = 1

, it does not depend on the number of alternative types of

{Variants}_{0}

For

n > 1

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