std::to_array
De cppreference.com
| 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.
Contenido |
[editar] 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).
| ||
[editar] 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]) }
[editar] 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" }
[editar] 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>{}); } |
[editar] 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); }
[editar] 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) |
