std::to_array

From cppreference.com

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 control library(C++26)
Technical specifications
Symbols index
External libraries

[edit]

Containers library

node-handle (C++17)
Sequence
array (C++11)
vector
vector<bool>
inplace_vector (C++26)
hive (C++26)
deque
forward_list (C++11)
list
Associative
set
multiset
map
multimap
Unordered associative
unordered_set (C++11)
unordered_multiset (C++11)
unordered_map (C++11)
unordered_multimap (C++11)
Adaptors
stack
queue
priority_queue
flat_set (C++23)
flat_multiset (C++23)
flat_map (C++23)
flat_multimap (C++23)
Views
span (C++20)
mdspan (C++23)
Tables
Iterator invalidation
Member function table
Non-member function table

Element access
array::at
array::operator[]
array::front
array::back
array::data
Operations
array::fill
array::swap

Iterators
array::beginarray::cbegin
array::endarray::cend
array::rbeginarray::crbegin
array::rendarray::crend

Capacity
array::empty
array::size
array::max_size

Non-member functions

operator==operator<=> (C++20)
get(std::array)
swap(std::array)
to_array (C++20)

operator|=operator<operator>operator<=operator>=

(until C++20)(until C++20)(until C++20)(until C++20)(until C++20)

Helper classes

tuple_size<std::array>

tuple_element<std::array>

Deduction guides(C++17)

[edit]

Defined in header`<array>`
template<class T,std::size_t N> constexprstd::array<std::remove_cv_t<T>, N> to_array( T(&a)[N]);	(1)	(since C++20)
template<class T,std::size_t N> constexprstd::array<std::remove_cv_t<T>, N> to_array( T(&&a)[N]);	(2)	(since C++20)

Creates astd::array from the one dimensional built-in arraya. Copying or moving multidimensional built-in array is not supported.

1) For everyi in0, ..., N - 1, copy-initializes result's correspond element witha[i]. This overload is ill-formed whenstd::is_constructible_v<T, T&> isfalse.

2) For everyi in0, ..., N - 1, move-initializes result's correspond element withstd::move(a[i]). This overload is ill-formed whenstd::is_move_constructible_v<T> isfalse.

Both overloads are ill-formed whenstd::is_array_v<T> istrue.

[edit]Parameters

a	-	the built-in array to be converted thestd::array
Type requirements
- `T` must meet the requirements ofCopyConstructible in order to use overload (1).
- `T` must meet the requirements ofMoveConstructible in order to use overload (2).

[edit]Return value

1)std::array<std::remove_cv_t<T>, N>{ a[0], ..., a[N-1]}

2)std::array<std::remove_cv_t<T>, N>{ std::move(a[0]), ..., std::move(a[N-1])}

[edit]Notes

There are some occasions whereclass template argument deduction ofstd::array cannot be used whileto_array is available:

to_array can be used when the element type of thestd::array is manually specified and the length is deduced, which is preferable when implicit conversion is wanted.
to_array can copy a string literal, while class template argument deduction constructs astd::array of a single pointer to its first character.

std::to_array<long>({3,4});// OK: implicit conversion// std::array<long>{3, 4};   // error: too few template argumentsstd::to_array("foo");// creates std::array<char, 4>{'f', 'o', 'o', '\0'}std::array{"foo"};// creates std::array<const char*, 1>{"foo"}

Feature-test macro	Value	Std	Feature
`__cpp_lib_to_array`	`201907L`	(C++20)	`std::to_array`

[edit]Possible implementation

to_array (1)
namespace detail{template<class T,std::size_t N,std::size_t...I>constexprstd::array<std::remove_cv_t<T>, N> to_array_impl(T(&a)[N],std::index_sequence<I...>){return{{a[I]...}};}} template<class T,std::size_t N>constexprstd::array<std::remove_cv_t<T>, N> to_array(T(&a)[N]){return detail::to_array_impl(a,std::make_index_sequence<N>{});}
to_array (2)
namespace detail{template<class T,std::size_t N,std::size_t...I>constexprstd::array<std::remove_cv_t<T>, N> to_array_impl(T(&&a)[N],std::index_sequence<I...>){return{{std::move(a[I])...}};}} template<class T,std::size_t N>constexprstd::array<std::remove_cv_t<T>, N> to_array(T(&&a)[N]){return detail::to_array_impl(std::move(a),std::make_index_sequence<N>{});}

to_array (1)

namespace detail{template<class T,std::size_t N,std::size_t...I>constexprstd::array<std::remove_cv_t<T>, N>        to_array_impl(T(&a)[N],std::index_sequence<I...>){return{{a[I]...}};}} template<class T,std::size_t N>constexprstd::array<std::remove_cv_t<T>, N> to_array(T(&a)[N]){return detail::to_array_impl(a,std::make_index_sequence<N>{});}

to_array (2)

namespace detail{template<class T,std::size_t N,std::size_t...I>constexprstd::array<std::remove_cv_t<T>, N>        to_array_impl(T(&&a)[N],std::index_sequence<I...>){return{{std::move(a[I])...}};}} template<class T,std::size_t N>constexprstd::array<std::remove_cv_t<T>, N> to_array(T(&&a)[N]){return detail::to_array_impl(std::move(a),std::make_index_sequence<N>{});}

[edit]Example

Run this code

#include <array>#include <memory>#include <string_view>#include <type_traits>#include <utility> // creates a constexpr array of string_view'sconstexprauto w1n= std::to_array<std::string_view>({"Mary","Patricia","Linda","Barbara","Elizabeth","Jennifer"});static_assert(std::is_same_v<decltype(w1n),conststd::array<std::string_view,6>>);static_assert(w1n.size()==6 and w1n[5]=="Jennifer"); int main(){// copies a string literalauto a1= std::to_array("foo");    static_assert(a1.size()==4); // deduces both element type and lengthauto a2= std::to_array({0,2,1,3});    static_assert(std::is_same_v<decltype(a2),std::array<int,4>>); // deduces length with element type specified// implicit conversion happensauto a3= std::to_array<long>({0,1,3});    static_assert(std::is_same_v<decltype(a3),std::array<long,3>>); auto a4= std::to_array<std::pair<int,float>>({{3,0.0f},{4,0.1f},{4, 0.1e23f}});    static_assert(a4.size()==3); // creates a non-copyable std::arrayauto a5= std::to_array({std::make_unique<int>(3)});    static_assert(a5.size()==1); // error: copying multidimensional arrays is not supported// char s[2][6] = {"nice", "thing"};// auto a6 = std::to_array(s);}