Array-Initialisierungs-Kompilierzeit - Contexpr-Sequenz

Question

Ich las this Frage zu SO.

Die Frage selbst ist nicht so interessant, aber ich frage mich, ob es existiert und wie man eine Kompilierzeitlösung implementiert.

Hinblick auf die erste Sequenz:

Alle Zahlen mit Ausnahme derjenigen, die von 3.

Die Reihenfolge sollte so etwas sein, unterteilt werden können:

[1, 2, 4, 5, 7, 8, 10, 11, 13, 14, ...] 

Durch Induktion Ich habe die mathematische Formel für diese Sequenz gefunden:

f(0) = 0; 
f(x > 0) = floor[(3x - 1)/2]; 

So habe ich eine C++ constexpr Funktion implementiert, die die i-ten Zahl in der Folge erzeugt:

#include <type_traits> 

template <typename T = std::size_t> 
constexpr T generate_ith_number(const std::size_t index) { 
    static_assert(std::is_integral<T>::value, "T must to be an integral type"); 

    if (index == 0) return 0; 
    return (3 * index - 1)/2; 
} 

Jetzt möchte ich erzeugen ein "Kompilierung-Array/Sequenz" speichert die ersten N-ten Nummern der Sequenz.

sollte die Struktur so etwas wie:

template <typename T, T... values> 
struct sequence {}; 

template <typename T, std::size_t SIZE> 
struct generate_sequence {}; // TODO: implement 

Fragen (mehr als eine, aber unter ihnen verwandt):

1) Wie diese Art von integer_sequence zu implementieren?

2) Ist es möglich, einen von dieser integer_sequence zur Kompilierzeit zu erstellen?

Answer 1

1) Wie implementiert man diese Art von integer_sequence?

template <std::size_t... Is> 
constexpr auto make_sequence_impl(std::index_sequence<Is...>) 
{ 
    return std::index_sequence<generate_ith_number(Is)...>{}; 
} 

template <std::size_t N> 
constexpr auto make_sequence() 
{ 
    return make_sequence_impl(std::make_index_sequence<N>{}); 
} 

---

2) Ist es möglich, ein std::array von diesen integer_sequence bei der Kompilierung zu bauen?

template <std::size_t... Is> 
constexpr auto make_array_from_sequence_impl(std::index_sequence<Is...>) 
{ 
    return std::array<std::size_t, sizeof...(Is)>{Is...}; 
} 

template <typename Seq> 
constexpr auto make_array_from_sequence(Seq) 
{ 
    return make_array_from_sequence_impl(Seq{}); 
} 

---

Verbrauch:

int main() 
{ 
    constexpr auto arr = make_array_from_sequence(make_sequence<6>()); 
    static_assert(arr[0] == 0); 
    static_assert(arr[1] == 1); 
    static_assert(arr[2] == 2); 
    static_assert(arr[3] == 4); 
    static_assert(arr[4] == 5); 
    static_assert(arr[5] == 7); 
} 

live example on wandbox.org

Answer 2

Es ist ziemlich einfach, das Array mit recht einfach Code in den letzten C++ zu generieren:

template<typename T, T N> 
constexpr auto make_constexpr_array(std::integral_constant<T, N>) 
{ 
    std::array<int,N> result = {}; 
    for (int i = 0; i < N; ++i) 
     result[i] = (3*i - 1)/2; 
    return result; 
} 

int main() 
{ 
    constexpr auto arr = make_constexpr_array(std::integral_constant<int, 6>{}); 
    static_assert(arr[0] == 0); 
    static_assert(arr[1] == 1); 
    static_assert(arr[2] == 2); 
    static_assert(arr[3] == 4); 
    static_assert(arr[4] == 5); 
    static_assert(arr[5] == 7); 
}