std::to_array
De cppreference.com
<tbody>
</tbody>
| Definido en el archivo de encabezado <array>
|
||
template<class T, std::size_t N> constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N]); |
(1) | (desde C++20) |
template<class T, std::size_t N> constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&&a)[N]); |
(2) | (desde C++20) |
Crea un std::array del array unidimensional integrado a. Los elementos de std::array se inicializan por copia del elemento correspondiente de a. No se apoya la copia o movimiento de arrays multidimensionales.
1) Para cada
i en 0, ..., N - 1, el resultado de la inicialización por copia se corresponde con el elemento a[i]. Esta sobrecarga está mal formada cuando std::is_constructible_v<T, T&> es false.2) Para cada
i in 0, ..., N - 1, el resultado de la inicialización por movimiento se corresponde con el elemento std::move(a[i]). Esta sobrecarga está mal formada cuando std::is_move_constructible_v<T> es false.Ambas sobrecargas están mal formadas cuando std::is_array_v<T> es true.
Parámetros
| a | - | El array integrado a convertirse a std::array. |
| Requisitos de tipo | ||
-T debe satisfacer los requisitos de CopyConstructible para poder usar la sobrecarga (1).
| ||
-T debe satisfacer los requisitos de MoveConstructible para poder usar la sobrecarga (2).
| ||
Valor de retorno
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]) }Notas
Hay algunas ocasiones donde la deducción de argumentos de plantillas de clase de std::array no puede usarse si to_array está disponible:
to_arraypuede usarse cuando el tipo de elemento destd::arrayse especifica manualmente y la longitud se deduce, que es preferible cuando se desea la conversión implícita.to_arraypuede copiar un literal de cadena, mientras que la deducción de argumentos de plantillas de clase construye unstd::arrayde un solo puntero a su primer carácter.
std::to_array<long>({3, 4}); // de acuerdo: conversión implícita
// std::array<long>{3, 4}; // ERROR: muy pocos argumentos de plantilla
std::to_array("foo"); // crea un std::array<char, 4>{ 'f', 'o', 'o', '\0' }
std::array{"foo"}; // crea un std::array<const char*, 1>{ +"foo" }
Posible implementación
| Primera versión |
|---|
namespace detail {
template <class T, std::size_t N, std::size_t... I>
constexpr std::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>
constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N])
{
return detail::to_array_impl(a, std::make_index_sequence<N>{});
}
|
| Segunda versión |
namespace detail {
template <class T, std::size_t N, std::size_t... I>
constexpr std::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>
constexpr std::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>{});
}
|
Ejemplo
Ejecuta este código
#include <type_traits>
#include <utility>
#include <array>
#include <memory>
int main()
{
// copia un literal de cadena
auto a1 = std::to_array("foo");
static_assert(a1.size() == 4);
// deduce tanto el tipo de elemento como la longitud
auto a2 = std::to_array({ 0, 2, 1, 3 });
static_assert(std::is_same_v<decltype(a2), std::array<int, 4>>);
// deduce la longitud con el tipo de elemento especificado
// ocurre la conversión implícita
auto 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, .0f }, { 4, .1f }, { 4, .1e23f } });
static_assert(a4.size() == 3);
// crea un std::array que no se puede copiar
auto a5 = std::to_array({ std::make_unique<int>(3) });
static_assert(a5.size() == 1);
// ERROR: no se apoya la copia de arrays multidimensionales
// char s[2][6] = { "cosita", "bonita" };
// auto a6 = std::to_array(s);
}
Véase también
| Crea un objeto std::array cuyo tamaño y opcionalmente tipo de elemento se deducen a partir de los argumentos. (plantilla de función) |