How can I initialize an array in compile-time with some elements given manually?

Question

I'm using an array of pointer to function. I wrote the code like this since some of elements can not be expressed with function template.

extern void zero(); // isr 0 is defined somewhere else

void one() {
  // isr 1
}

template <std::size_t N>
void Nth() {
  // isr N
}

using func = void (*)();
constexpr func interrupt_vector[256] = {
  &zero,
  &one,
  &Nth<2>,
  &Nth<3>,
  ...
  &Nth<254>,
  &Nth<255>,
};

I've read about static table generation with variadic template, but those were about initializing the whole array.

How can I simplify the code?

@ Actually It's a part of interrupt vector. Since it should be called directly, I cannot use template specialization such as

template <>
void Nth<0>() {
  zero();
}

@@ Edited the code. I think that cout things were confusing.

It's the same technique. You just use a different index pack — R. Martinho Fernandes, Feb 10 '14 at 12:54
If I understand you correctly, what you want is to automate the listing `&Nth<2>` ... `&Nth<255>` given the number 255 (or 256). In this case you should be able to write this with an index helper, like here: http://stackoverflow.com/a/15036110/592323, but starting with 2 instead of 0. Then simply put the two special cases in front of the unpacking, like `{ &zero, &one, &Nth... }`, where `MyIndex` is somthing like `size_t ...Is` from the linked answer. — leemes, Feb 10 '14 at 12:57

Simple · Accepted Answer · 2014-02-11T09:12:50.667

If you can change to use std::array then something like this would work.

using func = void (*)();

template<int...>
struct index_sequence { };

template<int From, int N, int... Is>
struct make_index_sequence_from : make_index_sequence_from<From, N - 1, N - 1, Is...> { };

template<int From, int... Is>
struct make_index_sequence_from<From, From, Is...> : index_sequence<Is...> { };

template<int... Is> constexpr
std::array<func, 256> make_interrupt_vector_array(index_sequence<Is...>)
{
    return {{zero, one, Nth<Is>...}};
}

constexpr
std::array<func, 256> make_interrupt_vector_array()
{
    return make_interrupt_vector_array(make_index_sequence_from<2, 256>());
}

constexpr auto interrupt_vector = make_interrupt_vector_array();

score 1 · Answer 2 · answered Feb 10 '14 at 12:54

1

I would recommended that you wrap your function around a class/struct so that you can take advantage of template specialization and declare your function as static inside of the class/struct

#include <iostream>

template <std::size_t N>
struct Nth 
{
    static void print()
    {
        std::cout << N << "!!" << std::endl;
    }
};

template <>
struct Nth<0>
{
    static void print()
    {
        std::cout << "Zero!!" << std::endl;
    }
};

template <>
struct Nth<1>
{
    static void print()
    {
        std::cout << "One!!" << std::endl;
    }
};

int main()
{
    Nth<0>::print();
    Nth<1>::print();
    Nth<2>::print();
}

answered Feb 10 '14 at 12:54

Caesar

9,483
8
40
66

This doesn't answer the question since OP said the array shouldn't contain indirect function calls. But I guess you could use class template specialization with "getters" returning function pointers. Like `struct Nth<0> { static FunctionType getFunction { return &zero; } };` and so on – leemes Feb 10 '14 at 13:01
What's the difference from the function template? – Inbae Jeong Feb 10 '14 at 13:01
@leemes Why put them in an array? It takes away any advantage you get from the template specialization. – Caesar Feb 10 '14 at 13:04
@kukyakya function templates can't have template specialization in your case, so this is a way to get around it. – Caesar Feb 10 '14 at 13:04
@Caesar Because it's an interrupt vector. I'm not calling the functions, but MCU does. – Inbae Jeong Feb 10 '14 at 13:05
@kukyakya Well, in that case you are not getting any benefit from template specialization. Might as well just pass in the value as a parameter. – Caesar Feb 10 '14 at 13:07

Jarod42 · Answer 3 · 2014-02-10T13:35:23.543

Following may help:

#if 1 // Not in C++11
#include <cstdint>

template <std::size_t ...> struct index_sequence {};

template <std::size_t N, std::size_t ...Is>
struct make_index_sequence : make_index_sequence <N - 1, N - 1, Is...> {};

template <std::size_t ... Is>
struct make_index_sequence<0, Is...> : index_sequence<Is...> {};

#endif // make_index_sequence


using func = void (*)();

namespace detail
{

// general case
template <std::size_t N>
struct FuncPtr { static constexpr func value = &Nth<N>; };

// Some specializations // not necessary at the beginning
template <>
struct FuncPtr<0u> { static constexpr func value = &zero; };

template <>
struct FuncPtr<1u> { static constexpr func value = &one; };

// Function to create the array:
template <std::size_t ... Is>
constexpr std::array<func, sizeof...(Is)>
FuncPtrArray(index_sequence<Is...>)
{
    return std::array<func, sizeof...(Is)>{{FuncPtr<Is>::value...}};
}

} // namespace detail

constexpr std::array<func, 256> interrupt_vector =
    detail::FuncPtrArray(make_index_sequence<256>());

How can I initialize an array in compile-time with some elements given manually?

3 Answers3