c++ - 传递 constexpr 函数以在编译时使用

Question

我正在尝试创建一种在编译时生成 std::array 的简单方法。到目前为止，要想找到一种在编译时传递 constexpr 函数的好方法一直很困难。到目前为止我找到的解决方法是这样的。

#include <iostream>                                                                
#include <array>                                                                   
namespace a {                                                                      
constexpr int f(const int & i) { return i * i * i;}                                
#include "generate_with_function.hpp"                                              
}                                                                                  
int main()                                                                         
{                                                                                  
    auto arr  = a::generator<false,10,0>::array;                                   
    for (auto i : arr) {                                                           
        std::cout << i << " ";                                                     
    }                                                                              
    return 0;                                                                      
}  

这基本上假设您将定义一个名为 f 的函数，并且我将其包装在一个命名空间中，以防我想做一个不同的。我想知道是否有更聪明的方法来传递函数并在编译时使用它。这里还有制作列表的代码。

template <bool B, size_t Count,int ... Nums>                                       
struct generator;                                                                  

template <size_t Count>                                                            
struct generator<false,Count,0>                                                    
{                                                                                  
    constexpr static std::array<int,Count> array                                   
        = generator<false,Count,1,f(0)>::array;                                    
};                                                                                 

template <size_t Count, int Current, int ... Results>                              
struct generator<false,Count,Current, Results...>                                  
{                                                                                  
    constexpr static std::array<int,Count>  array                                  
        = generator<Current+1==Count,Count,Current+1,f(Current), Results...>::array;
};                                                                                 

template <size_t Count, int Current, int ... Results>                              
struct generator<true,Count,Current,Results...>                                    
{                                                                                  
    constexpr static std::array<int,Count>  array{{Results...}};                   
}; 

在你问不之前，我实际上并没有真正需要这个。

正如@us2012 所指出的，我应该具体说明我更愿意拥有什么。

1. 现在在命名空间中环绕
2. 必须编写函数但实际上没有将它传递到任何地方
3. 并且不需要将函数命名为 f

Answer 1

您实际上可以将该函数用作模板参数，这里称为 Gen:

template <bool B, size_t Count, int Current, int Gen(size_t), int ... Nums>
struct generator;

template <size_t Count, int Current, int Gen(size_t), int ... Results>
struct generator<false,Count,Current, Gen, Results...>
{
    constexpr static std::array<int,Count>  array
         generator<Current+1==Count,Count,Current+1,Gen,
                   Gen(Current), Results...>::array;
};

template <size_t Count, int Current, int Gen(size_t), int ... Results>
struct generator<true,Count,Current,Gen,Results...>
{
    constexpr static std::array<int,Count>  array{{Results...}};
};

有了这个，它实际上可以将一个 constexpr 函数传递给模板(如果类型完全匹配):

// helper to hide the "internal" template parameters
template <size_t Count, int Gen(size_t)>
struct gen {                                                                 
   constexpr static std::array<int, Count> array = generator<false, Count, 0, Gen>::array;
};

constexpr int f(size_t i) { return i * i * i; }

int main()
{
    auto arr = gen<10,f>::array;
    for (auto i : arr) {
        std::cout << i << " ";
    }
    return 0;
}

您还可以切换 Gen(Current) 和 Results... 参数以获取“正确”数组索引处的值。