在现代 C++ 中使用模板替换函数指针数组

Question

我有一些遗留代码使用函数指针数组来模拟内存处理程序。
所以我现在正在尝试使用模板来获得相同的功能。
到目前为止，这是我尝试过的：

template <typename R, typename ...ARGS> using function = R(*)(ARGS...);
template<size_t Size> using ReadType    = function<SizedUInt<Size>, const uint32_t>;

// arrays to redeclare
std::array<ReadType<8>,   memory_handler_size> read_8_handler_;
std::array<ReadType<16>,  memory_handler_size> read_16_handler_;
std::array<ReadType<32>,  memory_handler_size> read_32_handler_;

template<size_t Size>
void initializeReadHandler(uint32_t begin,
                           uint32_t end,
                           ReadType<Size> func) {
    begin >>= 16;
    end >>= 16;
    for (uint32_t current = begin; current <= end; ++current) {
         //read_handler_[current & 0xFFFF] = func;
    }
}

如何声明读取处理程序数组以便使用模板化的initializeReadHandler() 函数对其进行初始化？
我不想使用std::function，因为我负担不起性能开销...

...编辑...
这是基于 Yakk 的回答、max66 备注和一些小修复（错字等）的代码：

template <typename R, typename ...ARGS> using function = R(*)(ARGS...);
template<size_t S> using ReadType    = function<SizedUInt<S>, const uint32_t>;

template<class ReadType>
using ReadHandlerType = std::array<ReadType, memory_handler_size>;

ReadHandler<8> read_8_handler_;
ReadHandler<16> read_16_handler_;
ReadHandler<32> read_32_handler_;

template<size_t S>
void initializeReadHandler(uint32_t begin,
                           uint32_t end,
                           ReadType<S> func) {
    begin >>= 16;
    end >>= 16;

    auto t = std::tie(read_8_handler_, read_16_handler_, read_32_handler_);
    for (uint32_t current = begin; current <= end; ++current) {
        auto& handler = std::get < ReadHandler<S>& >(t);
        handler[current & 0xFFFF] = func;
    }
}

像魅力一样工作：D 谢谢大家！

Answer 1

如果我理解正确并且您不想维护 read_8_handler_、read_16_handler_ 和 read_32_handler_ 全局变量（一种），我想您可以将它们包装为模板函数中的静态变量（按照 Quentin 的建议）

某事

 template <std::size_t S>
 std::array<ReadType<S>, memory_handler_size> & getHandler () 
   { static std::array<ReadType<S>, memory_handler_size> h; return h; }

所以你可以使用推导出来的Size模板参数来选择请求的函数

template<size_t Size>
void initializeReadHandler(uint32_t begin,
                           uint32_t end,
                           ReadType<Size> func) {
    begin >>= 16;
    end >>= 16;

    auto & handler = getHandler<Size>();

    for (uint32_t current = begin; current <= end; ++current) {
       handler[current & 0xFFFF] = func;
    }
}

但是，如果可能的话，我建议您将数组（通过引用）作为参数传递给函数。

Answer 2

虽然@max66 的回答很棒，但如果您想要绝对最小的代码更改，您可以在c++14 中执行此操作。

这不是必需的，但我喜欢清理类型：

template<class ReadType>
using handler_type = std::array<ReadType,   memory_handler_size>;
template<std::size_t S>
using handler_for_size = handler_type<ReadType<S>>;

handler_for_size<8> read_8_handler_;
handler_for_size<16> read_16_handler_;
handler_for_size<32> read_32_handler_;

然后initializeReadHandler:

template<size_t Size>
void initializeReadHandler(uint32_t begin,
                       uint32_t end,
                       ReadType<Size> func) {
  begin >>= 16;
  end >>= 16;
  for (uint32_t current = begin; current <= end; ++current) {
     auto& handler = std::get<handler_type<ReadType<Size>>( std::tie(read_8_handler_, read_16_handler_, read_32_handler_) );
     handler[current & 0xFFFF] = func;
  }
}

这里我们使用基于类型的get 和对零成本的引用获得正确的处理程序数组。

最大的不同是你可以留下你的全局read_8_handler_。如果没有理由使用全局read_8_handler_，请使用@max66 的答案。