std::define_static_array

template< ranges::input_range R >
consteval std::span<const ranges::range_value_t<R>> define_static_array( R&& r );

Befördert Array in statischen Speicher.

Sei N static_cast<std::size_t>(ranges::size(r)), wenn ranges::size(r) ein konstanter Ausdruck ist, oder std::dynamic_extent andernfalls. Die Wirkung ist äquivalent zu:

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);

Parameter

haben

Wenn die Größe von r nicht Null ist, ein span, konstruiert aus einem Array vom Typ const T[N] (wobei T ranges::range_value_t<R> und N die Größe von r ist). Jedes Element des Arrays wird aus dem Wert oder Objekt initialisiert, das durch std::meta::reflect_constant(static_cast<T>(*it)) repräsentiert wird, wobei it ein Iterator zum entsprechenden Element von r ist.

Andernfalls (die Größe von r ist Null) ein leerer span.

Anmerkungen

Als Template-Parameter-Objekt hat das resultierende Array-Objekt (falls vorhanden) eine statische Speicherdauer. Bereiche mit template-argument-äquivalentem Inhalt entsprechen demselben Array-Objekt.

Das Array-Objekt ist ein potenziell nicht eindeutiges Objekt.

Beispiel

#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();
}

0.0 51.4 102.9 154.3 205.7 257.1 308.6

Siehe auch