C++ 如何将基本代码snippit/模式转换为使用c+；11可变模板

以下简单的代码模式在图形编程中非常常见。
它创建一个层阵列，并在其上循环

struct Layer
{
    int n;
    void operator()(float value)
    {
    }
};

struct AnotherLayer
{
    int n;
    int m;
    void operator()(float value)
    {
    }
};

void process_layers(Layer_t* layer, size_t size, float value) 
{
    for (size_t n = 0; n < size; ++n)
        layer[n](value);
}

Layer a = {1};
Layer b = {2};
AnotherLayer c = {2,3};
typedef std::function < void (float) > Layer_t;
Layer_t layers [] = {a,b,c};
process_layers(layers, sizeof(layers)/sizeof(Layer), 100);

结构层 { int n； void运算符（）（浮点值） { } }; 构造另一层 { int n； int m； void运算符（）（浮点值） { } }; 无效处理层（层、大小、浮动值） { 对于（大小n=0；n层； 层_t层[]={a，b，c}； 工艺层（层，尺寸（层）/尺寸（层），100）； 我想将其转换为在c++11中使用varadic模板。你知道我该怎么做吗。这就是我想要的样子。有什么想法吗？这可能吗

template <int n>
struct Layer
{
    void operator()(float value)
    {
    }
};

template <int n, int m>
struct AnotherLayer
{
    void operator()(float value)
    {
    }
};

template <typename Layer1, typename Layer2, ...>
struct Layers  //process_layers
{
    void operator()(float value)
    {
        for (size_t n = 0; n < SIZEOF(Layer1,Layer2,...); ++n)
            Layer[N]()(value);
    }
};

模板
结构层
{
void运算符（）（浮点值）
{
}
};
模板
构造另一层
{
void运算符（）（浮点值）
{
}
};
模板
结构层//进程层
{
void运算符（）（浮点值）
{
对于（大小n=0；n

那我就可以这么做了

typedef Layers<Layer<1>, Layer<2>, AnotherLayer<3,8> > funky_layer_t;
typedef Layers<Layer<4>, Layer<5>, Layer<5>, AnotherLayer<6,7> > standard_layer_t;
typedef Layers<funky_layer_t, standard_layer_t> awesome_layer_t;

awesome_layer_t()(100);

typedef Layers funky\u layer\t；
typedef层标准层；
typedef layer\u layer\t；
层（100）；

---

注意：对于第二种方法，所有构造层的参数在编译时都是已知的

我相信您可以使用以下常规函数模板来完成此操作：

/* Base case: If you have no layers to apply, do nothing. */
void executeLayers() {
    // Deliberately empty.
}

/* Recursive step: If you have at least one layer, apply it, then apply the
 * remaining layers.
 */
template <typename Head, typename... Tail> 
void executeLayers(Head head, Tail... tail) {
    head();              // Execute the first layer
    executeLayers(tail); // Execute the remaining layers
}

---

希望这有帮助

我相信您可以使用以下常规函数模板来完成此操作：

/* Base case: If you have no layers to apply, do nothing. */
void executeLayers() {
    // Deliberately empty.
}

/* Recursive step: If you have at least one layer, apply it, then apply the
 * remaining layers.
 */
template <typename Head, typename... Tail> 
void executeLayers(Head head, Tail... tail) {
    head();              // Execute the first layer
    executeLayers(tail); // Execute the remaining layers
}

---

希望这有帮助

您给出的示例非常简单，可以重新使用可变模板

template<typename Func> void process(Func &&f) {} // base case for zero items

// overload for at least one item
template<typename Func, typename FirstItem, typename... Items>
void process(Func &&f, FirstItem &&fi, Items &&...is) {
    std::forward<Func>(f)(std::forward<FirstItem>(fi));          // f(fi);
    process(std::forward<Func>(f), std::forward<Items>(is)...);  // process(f,is...);
}

Layer a = {1};
Layer b = {2};
Layer c = {3};

process([](Layer &l){ l(100); },
        a, b, c);

---

这是您的

很棒的\u layer\t

转录来纠正可变模板语法，但我仍然不知道您想要实现什么，所以我不能说这是否是一个好方法。这实际上并没有在编译时调用

操作符（）

s，它只安排在运行时默认构造一组对象，然后在运行时再次调用

操作符（）

template <int n>
struct Layer
{
    int operator()(float value)
    {
        std::printf("L %d %e\n",n,value);
        return 0;
    }
};

template <int n, int m>
struct AnotherLayer
{
    int operator()(float value)
    {
        std::printf("AL %d %d %e\n",n,m,value);
        return 0;
    }
};

template <typename... Ls>
struct Layers  //process_layers
{
    int operator()(float value)
    {
        struct Tmp {
            void operator() (...) {}
        };
        Tmp()( Ls()(value)...);
        return 0;
    }
};

typedef Layers<Layer<1>, Layer<2>, AnotherLayer<3,8> > funky_layer_t;
typedef Layers<Layer<4>, Layer<5>, Layer<5>, AnotherLayer<6,7> > standard_layer_t;
typedef Layers<funky_layer_t, standard_layer_t> awesome_layer_t;

int main() {
    awesome_layer_t()(100);
}

模板
结构层
{
int运算符（）（浮点值）
{
标准：：printf（“L%d%e\n”，n，值）；
返回0；
}
};
模板
构造另一层
{
int运算符（）（浮点值）
{
标准：：printf（“AL%d%d%e\n”，n，m，值）；
返回0；
}
};
模板
结构层//进程层
{
int运算符（）（浮点值）
{
结构Tmp{
void运算符（）（…）{}
};
Tmp（）（Ls（）（值）…）；
返回0；
}
};
typedef Layers funky_layer_t；
typedef层标准层；
typedef layer\u layer\t；
int main（）{
层（100）；
}

您给出的示例非常简单，可以重新使用可变模板

template<typename Func> void process(Func &&f) {} // base case for zero items

// overload for at least one item
template<typename Func, typename FirstItem, typename... Items>
void process(Func &&f, FirstItem &&fi, Items &&...is) {
    std::forward<Func>(f)(std::forward<FirstItem>(fi));          // f(fi);
    process(std::forward<Func>(f), std::forward<Items>(is)...);  // process(f,is...);
}

Layer a = {1};
Layer b = {2};
Layer c = {3};

process([](Layer &l){ l(100); },
        a, b, c);

---

这是您的

很棒的\u layer\t

转录来纠正可变模板语法，但我仍然不知道您想要实现什么，所以我不能说这是否是一个好方法。这实际上并没有在编译时调用

操作符（）

s，它只安排在运行时默认构造一组对象，然后在运行时再次调用

操作符（）

template <int n>
struct Layer
{
    int operator()(float value)
    {
        std::printf("L %d %e\n",n,value);
        return 0;
    }
};

template <int n, int m>
struct AnotherLayer
{
    int operator()(float value)
    {
        std::printf("AL %d %d %e\n",n,m,value);
        return 0;
    }
};

template <typename... Ls>
struct Layers  //process_layers
{
    int operator()(float value)
    {
        struct Tmp {
            void operator() (...) {}
        };
        Tmp()( Ls()(value)...);
        return 0;
    }
};

typedef Layers<Layer<1>, Layer<2>, AnotherLayer<3,8> > funky_layer_t;
typedef Layers<Layer<4>, Layer<5>, Layer<5>, AnotherLayer<6,7> > standard_layer_t;
typedef Layers<funky_layer_t, standard_layer_t> awesome_layer_t;

int main() {
    awesome_layer_t()(100);
}

模板
结构层
{
int运算符（）（浮点值）
{
标准：：printf（“L%d%e\n”，n，值）；
返回0；
}
};
模板
构造另一层
{
int运算符（）（浮点值）
{
标准：：printf（“AL%d%d%e\n”，n，m，值）；
返回0；
}
};
模板
结构层//进程层
{
int运算符（）（浮点值）
{
结构Tmp{
void运算符（）（…）{}
};
Tmp（）（Ls（）（值）…）；
返回0；
}
};
typedef Layers funky_layer_t；
typedef层标准层；
typedef layer\u layer\t；
int main（）{
层（100）；
}

这并不是对可变模板的建设性使用。模板是用于处理各种类型的编译时构造。只需使用一个

std:：vector

就可以拥有一个可变大小的数组，它可以收缩、增长、迭代等。为什么模板层类更适合您？模板在这里的作用是什么？我在C++代码上有非常糟糕的经验，其中强制使用模板（以前的程序员有一本很好的模板……），然后我可以在编译时构造非常复杂的层组合。例如：typedef Layers clean_layer_t；这不是对可变模板的建设性使用。模板是用于处理各种类型的编译时构造。只需使用一个

std:：vector

就可以拥有一个可变大小的数组，它可以收缩、增长、迭代等。为什么模板层类更适合您？模板在这里的作用是什么？我在C++代码上有非常糟糕的经验，其中强制使用模板（以前的程序员有一本很好的模板……），然后我可以在编译时构造非常复杂的层组合。例如：typedef Layers clean_layer_t；我没有尝试过这个，但是寻找新模式的动机是在编译时构造复杂的层组合。我看不出你的例子是如何把我们推向那个方向的。另外，您的进程函数有点难以理解，因为有所有这些std:：forward。>>您希望在编译时执行的计算到底是什么？这纯粹是为了合成糖。我想通过每个层传递一个图像缓冲区。>>层层[]={{1}，{2}，{3}这不起作用，因为它假设每个层都有相同的构造函数。每一层可能彼此非常不同。唯一相似的是操作符（）（int）原型。在您的示例中，

层的类型似乎完全不相关。它可以是一些非常复杂的构造类型或int，只要执行任何操作即可