0

我正在尝试一种简单的方法来std::array在编译时生成 's。到目前为止，要找出一种在编译时传递 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
4

1 回答 1

2

您实际上可以将该函数用作模板参数，此处称为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...参数以获取“正确”数组索引处的值。

于 2013-10-10T01:40:55.470 回答