std::variant<Types...>::visit

template< class Self, class Visitor > constexpr decltype(auto) visit( this Self&& self, Visitor&& vis );	(1)	(since C++26)
template< class R, class Self, class Visitor > constexpr R visit( this Self&& self, Visitor&& vis );	(2)	(since C++26)

Applies the visitor vis (a Callable that can be called with any combination of types from the variant) to the variant held by self.

Given type V as decltype(std::forward_like<Self>(std::declval<variant>())), the equivalent call is:

1) return std::visit(std::forward<Visitor>(vis), (V) self);.

2) return std::visit<R>(std::forward<Visitor>(vis), (V) self);.

Parameters

vis	-	a Callable that accepts every possible alternative from the variant
self	-	variant to pass to the visitor

Return value

1) The result of the std::visit invocation.

2) Nothing if R is (possibly cv-qualified) void; otherwise the result of the std::visit<R> invocation.

Exceptions

Only throws if the call to std::visit throws.

Notes

Feature-test macro	Value	Std	Feature
`__cpp_lib_variant`	`202306L`	(C++26)	member `visit`

Example

Run this code

#include <print>
#include <string>
#include <string_view>
#include <variant>
 
struct Base {};
struct Derived : Base {};
 
// helper type for the visitor
template<class... Ts>
struct overloads : Ts... { using Ts::operator()...; };
 
// the variant to visit
using var_t = std::variant<int, std::string, Derived>;
 
int main()
{
    const auto visitor = overloads
    {
        [](int i){ std::print("int = {}\n", i); },
        [](std::string_view s){ std::println("string = “{}”", s); },
        [](const Base&){ std::println("base"); }
    };
 
    const var_t var1 = 42, var2 = "abc", var3 = Derived();
 
#if (__cpp_lib_variant >= 202306L)
    var1.visit(visitor);
    var2.visit(visitor);
    var3.visit(visitor);
#else
    std::visit(visitor, var1);
    std::visit(visitor, var2);
    std::visit(visitor, var3);
#endif
}

Output:

int = 42
string = “abc”
base

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

Member functions
variant::variant
variant::~variant
variant::operator=
Observers
variant::index
variant::valueless_by_exception
Modifiers
variant::emplace
variant::swap
Visitation
variant::visit (C++26)
Non-member functions
visit(std::variant)
holds_alternative
get(std::variant)
get_if
operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20)
swap(std::variant)
Helper classes
monostate
bad_variant_access
variant_size
variant_alternative
hash<std::variant>
Helper objects
variant_npos