相关疑难解决方法(0)

我正在尝试存储std::tuple不同数量的值,这些值稍后将用作调用与存储类型匹配的函数指针的参数.

我创建了一个简化的示例,显示了我正在努力解决的问题:

#include <iostream>
#include <tuple>

void f(int a, double b, void* c) {
  std::cout << a << ":" << b << ":" << c << std::endl;
}

template <typename ...Args>
struct save_it_for_later {
  std::tuple<Args...> params;
  void (*func)(Args...);

  void delayed_dispatch() {
     // How can I "unpack" params to call func?
     func(std::get<0>(params), std::get<1>(params), std::get<2>(params));
     // But I *really* don't want to write 20 versions of dispatch so I'd rather 
     // write something like:
     func(params...); // Not legal
  }
}; …

可以在编译时定义静态数组,如下所示:

const std::size_t size = 5;    
unsigned int list[size] = { 1, 2, 3, 4, 5 };

问题1 - 是否可以通过使用各种元编程技术在编译时"以编程方式"分配这些值？

问题2 - 假设数组中的所有值都是相同的barr,是否可以在编译时以编程方式选择性地分配值？

例如:

const std::size_t size = 7;        
unsigned int list[size] = { 0, 0, 2, 3, 0, 0, 0 };

1. 欢迎使用C++ 0x的解决方案
2. 阵列可能非常大,几百个元素长
3. 现在的数组只包含POD类型
4. 还可以假设,以静态编译时兼容的方式预先知道阵列的大小.
5. 解决方案必须是C++ (没有脚本,没有宏,没有pp或基于代码生成器的解决方案)

更新: Georg Fritzsche的解决方案非常棒,需要一些工作才能在msvc和intel编译器上进行编译,但这仍然是解决问题的一种非常有趣的方法.

编译下面的代码时,我在VC2010中遇到错误C2078.

struct A
  {
  int foo;
  double bar;
  };

std::array<A, 2> a1 = 
  // error C2078: too many initializers
  {
    {0, 0.1},
    {2, 3.4}
  };

// OK
std::array<double, 2> a2 = {0.1, 2.3};

我发现正确的语法a1是

std::array<A, 2> a1 = 
  {{
    {0, 0.1},
    {2, 3.4}
  }};

问题是:为什么需要额外的括号a1但不是必需的a2？

更新

这个问题似乎并不特定于std :: array.一些例子:

struct B
  {
  int foo[2];
  };

// OK
B meow1 = {1,2};
B bark1 = {{1,2}};

struct C
  {
  struct 
    { 
    int a, b; 
    } …

应用程序图像的实现具有通过由编译器计算其指数的函数初始化它的元素,并已存储在数据部分的结果的C++ 11阵列的一种方式(.RODATA)是使用模板,部分特和constexpr如下:

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

constexpr int N = 1000000;
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 << …

可能重复:
在C++编译时以编程方式创建静态数组

我有很多数据存储在固定数组中,其元素取决于位置.可以在编译时计算每个元素的值.

我的代码几乎就像:

int fun(int p) // maybe constexpr
{
    return 0x1<<p;
}

int a[17] = {
    repeat_fun_from_0_to_16();
};

因为所有的值都可以在编译时确定,所以应该有办法做到这一点,我想.

我还检查了repeat()boost.assignment中有一个,但不知道如何在这种情况下使用它.

我已经发现了两个好方法在编译时间初始化积分阵列这里和这里.

不幸的是,两者都不能直接转换为初始化浮点数组; 我发现我在模板元编程方面不够合适,无法通过反复试验来解决这个问题.

首先让我声明一个用例:

constexpr unsigned int SineLength  = 360u;
constexpr unsigned int ArrayLength = SineLength+(SineLength/4u);
constexpr double PI = 3.1415926535;

float array[ArrayLength];

void fillArray(unsigned int length)
{
  for(unsigned int i = 0u; i < length; ++i)
    array[i] = sin(double(i)*PI/180.*360./double(SineLength));
}

正如你所看到的,至于信息的可用性推移,这种阵列可以被宣布constexpr.

但是,对于链接的第一种方法,生成器函数f必须如下所示:

constexpr float f(unsigned int i)
{
  return sin(double(i)*PI/180.*360./double(SineLength));
}

这意味着float需要类型的模板参数.这是不允许的.

现在,我想到的第一个想法是将float存储在一个int变量中 - 计算后数组索引没有任何反应,所以假装它们是另一种类型(只要字节长度相等) )完全没问题.

但请看:

constexpr int f(unsigned int i)
{
  float output = sin(double(i)*PI/180.*360./double(SineLength)); …

我想使用数学函数在编译时填充constexpr std :: array。有可能以简单的方式吗？

我找到了以下解决方案：C ++ 11：数组的编译时间计算。但是，还有其他仅使用std的现代解决方案吗？这似乎让我感到困惑。

int main()
{
   // This is the array I need to fill
   constexpr std::array<double, 100000> elements;
   for (int i=0; i!=100000; ++i)
   {
      // Each element is calculated using its position with long exponential maths.
      elements[i] = complexFormula(i); // complexFormula is constexpr
   }


   double anyVal = elements[43621];
   // ...
}