std::define_static_array
| Definido en el encabezado <meta>
|
||
template< ranges::input_range R >
consteval std::span<const ranges::range_value_t<R>> define_static_array( R&& r );
|
(desde C++26) | |
Promueve un arreglo al almacenamiento estático.
Sea N igual a static_cast<std::size_t>(ranges::size(r)) si ranges::size(r) es una expresión constante, o std::dynamic_extent en caso contrario. El efecto es equivalente a:
using T = ranges::range_value_t<R>;
std::meta::info array = std::meta::reflect_constant_array(r);
if (std::meta::is_array_type(std::meta::type_of(array)))
return std::span<const T, N>(std::meta::extract<const T*>(array),
std::meta::extent(std::meta::type_of(array)));
else
return std::span<const T, N>(static_cast<const T*>(nullptr), 0);
Parámetros
| r | - | un input_range cuyos elementos son copiables y tienen tipo estructural |
Valor de retorno
Si el tamaño de r no es cero, un span construido a partir de un arreglo de tipo const T[N] (donde T es ranges::range_value_t<R> y N es el tamaño de r). Cada elemento del arreglo se inicializa a partir del valor u objeto representado por std::meta::reflect_constant(static_cast<T>(*it)), donde it es un iterador al elemento correspondiente de r.
En caso contrario (el tamaño de r es cero), un span vacío.
Notas
Como objeto parámetro de plantilla, el objeto arreglo resultante (si existe) tiene duración de almacenamiento estática. Los rangos con contenidos equivalentes a argumentos de plantilla corresponden al mismo objeto arreglo.
El objeto arreglo es un objeto potencialmente no único.
| Macro de prueba de características | Valor | Estándar | Característica |
|---|---|---|---|
__cpp_lib_define_static |
202506L |
(C++26) | std::define_static_array
|
Ejemplo
#include <algorithm>
#include <meta>
#include <print>
#include <vector>
constexpr std::vector<double> precompute_angles(std::size_t size)
{
std::vector<double> angles(size);
for (int i{}; double& angle : angles)
angle = 360.0 / size * i++;
return angles;
}
consteval std::span<const double> precompute_angles_arr(std::size_t size)
{
std::vector<double> angles = precompute_angles(size);
return std::define_static_array(angles);
}
int main()
{
// std::vector<double> angles = precompute_angles(7);
// error: call to consteval function ‘precompute_angles(7)’ is not a constant
// expression because it refers to a result of ‘operator new’
std::span<const double> angles = precompute_angles_arr(7);
for (double angle : angles)
std::print("{:.1f} ", angle);
std::println();
}
Salida:
0.0 51.4 102.9 154.3 205.7 257.1 308.6
Véase también
(C++26) |
promueve una cadena de tiempo de compilación al almacenamiento estático, devolviendo un puntero al primer carácter de la cadena estática (plantilla de función) |
(C++26) |
promueve un valor de tiempo de compilación al almacenamiento estático, devolviendo un puntero al objeto estático (plantilla de función) |
(C++26) |
promueve un arreglo de tiempo de compilación al almacenamiento estático, devolviendo una reflexión que representa el arreglo estático (plantilla de función) |