Question

我正在使用一个指向函数的指针数组。我编写了这样的代码，因为有些元素无法用函数模板表示。

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>,
};

我已经阅读过使用可变参数模板生成静态表，但那些是关于初始化整个数组的。

如何简化代码？

@实际上它是中断向量的一部分。由于它应该直接调用，我不能使用模板专业化，如

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

@@编辑代码。我认为cout事情令人困惑。

Answer 1

如果您可以更改为使用std::array，那么这样的事情就可以了。

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

Answer 2

我建议你围绕一个类/结构包装你的函数，这样你就可以利用模板特化并在类/ struct中将你的函数声明为static

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

Answer 3

以下可能会有所帮助：

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

如何在编译时使用手动给定的元素初始化数组？

3 个答案: