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

0 \leq i < n

, let

V_{i}

denote the type
decltype(as-variant(std::forward<

{Variants}_{i}

{vars}_{i}

))).

Constraints:

V_{i}

is a valid type for all

0 \leq i < n

Let V denote the pack of types

V_{i}

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

Such a pack is valid if

0 \leq m_{i} < {variant_size_v<remove_reference_t<V}_{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<V>(vars))...) // see [func.require] for the first form and INVOKE<R>(std::forward<Visitor>(vis), GET<m>(std::forward<V>(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 as-variant(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 (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

n = 1

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

V_{0}

For

n > 1

, 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]).

Constraints: The call to visit does not use an explicit template-argument-list that begins with a type template-argument.

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);

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.

22 General utilities library [utilities]

22.6 Variants [variant]

22.6.7 Visitation [variant.visit]

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.