C++11：数组的编译时计算

假设我有一些 constexpr 函数 f：

constexpr int f(int x) { ... }

我在编译时知道一些 const int N ：

Either

#define N ...;

or

const int N = ...;

根据您的回答的需要。

我想要一个 int 数组 X：

int X[N] = { f(0), f(1), f(2), ..., f(N-1) }

这样函数会在编译时进行计算，X 中的条目由编译器计算，结果会放置在我的应用程序映像的静态区域中，就像我在 X 初始值设定项列表中使用整数文字一样。

我有什么办法可以写这个吗？ （例如使用模板或宏等）

我拥有的最好的：（感谢 Flexo）

#include <iostream>
#include <array>
using namespace std;

constexpr int N = 10;
constexpr int f(int x) { return x*2; }

typedef array<int, N> A;

template<int... i> constexpr A fs() { return A{{ f(i)... }}; }

template<int...> struct S;

template<int... i> struct S<0,i...>
{ static constexpr A gs() { return fs<0,i...>(); } };

template<int i, int... j> struct S<i,j...>
{ static constexpr A gs() { return S<i-1,i,j...>::gs(); } };

constexpr auto X = S<N-1>::gs();

int main()
{
        cout << X[3] << endl;
}

对于这个问题，有一个纯 C++11（没有 boost，也没有宏）的解决方案。使用与以下相同的技巧这个答案 https://stackoverflow.com/a/7858971/168175我们可以构建一个数字序列并将它们解压以调用f构建一个std::array:

#include <array>
#include <algorithm>
#include <iterator>
#include <iostream>

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

template<int N, int ...S>
struct gens : gens<N-1, N-1, S...> { };

template<int ...S>
struct gens<0, S...> {
  typedef seq<S...> type;
};

constexpr int f(int n) {
  return n;
}

template <int N>
class array_thinger {
  typedef typename gens<N>::type list;

  template <int ...S>
  static constexpr std::array<int,N> make_arr(seq<S...>) {
    return std::array<int,N>{{f(S)...}};
  }
public:
  static constexpr std::array<int,N> arr = make_arr(list()); 
};

template <int N>
constexpr std::array<int,N> array_thinger<N>::arr;

int main() {
  std::copy(begin(array_thinger<10>::arr), end(array_thinger<10>::arr), 
            std::ostream_iterator<int>(std::cout, "\n"));
}

（使用 g++ 4.7 测试）

你可以跳过std::array完全需要更多的工作，但我认为在这种情况下，使用它更干净、更简单std::array.

您还可以递归地执行此操作：

#include <array>
#include <functional>
#include <algorithm>
#include <iterator>
#include <iostream>

constexpr int f(int n) {
  return n;
}

template <int N, int ...Vals>
constexpr
typename std::enable_if<N==sizeof...(Vals),std::array<int, N>>::type
make() {
  return std::array<int,N>{{Vals...}};
}

template <int N, int ...Vals>
constexpr
typename std::enable_if<N!=sizeof...(Vals), std::array<int,N>>::type 
make() {
  return make<N, Vals..., f(sizeof...(Vals))>();  
}

int main() {
  const auto arr = make<10>();
  std::copy(begin(arr), end(arr), std::ostream_iterator<int>(std::cout, "\n"));
}

这可以说更简单。