# std::variant_size, std::variant_size_v

> C++ Atlas: `cppatlas.com/w/cpp/utility/variant/variant_size` | Source: https://en.cppreference.com/w/cpp/utility/variant/variant_size | Domain: Utility | Standards: C++11, C++14, C++17

Provides access to the number of alternatives in a possibly cv-qualified variant as a compile-time constant expression.

## Official Specification Summary (cppreference)

```cpp
// Defined in header <variant>

template< class T >
struct variant_size; /* undefined */ // (1) (since C++17)

template< class... Types >
struct variant_size<std::variant<Types...>>
    : std::integral_constant<std::size_t, sizeof...(Types)> {}; // (2) (since C++17)

template< class T >
class variant_size<const T>; // (3) (since C++17)

template< class T >
class variant_size<volatile T>; // (4) (since C++17) (deprecated in C++20)

template< class T >
class variant_size<const volatile T>; // (5) (since C++17) (deprecated in C++20)
```

Provides access to the number of alternatives in a possibly cv-qualified variant as a compile-time constant expression.

Formally,

2) meets the *UnaryTypeTrait* requirements with a base characteristic of `std::integral_constant<std::size_t, sizeof...(Types)>`

3-5) meets the *UnaryTypeTrait* requirements with a base characteristic of `std::integral_constant<std::size_t, std::variant_size<T>::value>`

#### Helper variable template

```cpp
template< class T >
constexpr std::size_t variant_size_v = std::variant_size<T>::value; // (since C++17)
```

### Inherited from std::integral_constant

#### Member constants

- `value` [static]: `sizeof...(Types)` (public static member constant)

#### Member functions

- `operator std::size_t`: converts the object to `std::size_t`, returns `value` (public member function)
- `operator()` (C++14): returns `value` (public member function)

#### Member types

**Type — Definition**

- `value_type`: `std::size_t`
- `type`: `std::integral_constant<std::size_t, value>`

#### Notes

All specializations of `std::variant_size` satisfy *UnaryTypeTrait* with *base characteristic* `std::integral_constant<std::size_t, N>` for some `N`.

#### Example

```cpp
#include <any>
#include <variant>

static_assert(std::variant_size_v<std::variant<>> == 0);
static_assert(std::variant_size_v<std::variant<int>> == 1);
static_assert(std::variant_size_v<std::variant<int, int>> == 2);
static_assert(std::variant_size_v<std::variant<int, int, int>> == 3);
static_assert(std::variant_size_v<std::variant<int, float, double>> == 3);
static_assert(std::variant_size_v<std::variant<std::monostate, void>> == 2);
static_assert(std::variant_size_v<std::variant<const int, const float>> == 2);
static_assert(std::variant_size_v<std::variant<std::variant<std::any>>> == 1);

int main() {}
```

#### See also

- [`variant_alternative`](https://en.cppreference.com/w/cpp/utility/variant/variant_alternative) (C++17), [`variant_alternative_t`](https://en.cppreference.com/w/cpp/utility/variant/variant_alternative): obtains the type of the alternative specified by its index, at compile time (class template) (alias template)
- [`std::tuple_size<std::tuple>`](https://en.cppreference.com/w/cpp/utility/tuple/tuple_size) (C++11): obtains the size of a `tuple` (class template specialization)

---
Attribution: content from https://en.cppreference.com/w/cpp/utility/variant/variant_size (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.