Question

我想为几个可能类的几种组合编写基准代码。如果我自己编写每个组合，它就变成了一个难以维护的混乱。因此，我正在寻找一种通过模板自动组合每种类型的方法，类似于以下伪代码：

for (typename HashFuction : Sha256, Sha512, Sa512_256, Sha3_256, Sha3_512) {
   for (typename KeyingWrapper : TwoPassKeyedHash, OnePassKeyedHash, PlainHash) {
      for (typename InstantiatedGetLeaf: GetLeaf<8>, GetLeaf<1024>) {
         for (typename algorithm : algA, algB, algC) {
            runAndTime<HashFunction,KeyingWrapper,
                       InstantiatedGetLeaf,algorithm>(someArgs);
         }
       }
    }
 }

其中Sha256，...，TwoPassKeyedHash，...是类型。

我正在寻找的代码应该在功能上等同于以下内容：

runAndTime<Sha256,TwoPassKeyedHash,GetLeaf<8>,algA>(someArgs);
runAndTime<Sha256,TwoPassKeyedHash,GetLeaf<8>,algB>(someArgs);
runAndTime<Sha256,TwoPassKeyedHash,GetLeaf<8>,algC>(someArgs);

runAndTime<Sha256,TwoPassKeyedHash,GetLeaf<1024>,algA>(someArgs);
runAndTime<Sha256,TwoPassKeyedHash,GetLeaf<1024>,algB>(someArgs);
runAndTime<Sha256,TwoPassKeyedHash,GetLeaf<1024>,algC>(someArgs);

runAndTime<Sha256,OnePassKeyedHash,GetLeaf<8>,algA>(someArgs);
runAndTime<Sha256,OnePassKeyedHash,GetLeaf<8>,algB>(someArgs);
runAndTime<Sha256,OnePassKeyedHash,GetLeaf<8>,algC>(someArgs);

// And 99 further lines…

在Peregring-lk的帮助下，我来到了

#include <iostream>

template<typename Aux_type>
void test_helper()
{}

template<typename Aux_type, typename Head, typename... Tail>
void test_helper() {
   std::cout << Head::i;
   test_helper<Aux_type, Tail...>();
}

template<typename... Args>
void test()
{
    test_helper<void, Args...>();
}

struct A{
   static const int i=1;
};

struct B{
   static const int i=2;
};

int main() {
   test<A, B>();
   return 0;
}

但我还没有看到如何迭代该递归以获得嵌套循环。任何帮助将不胜感激。

（编辑：代码重组并包含Peregring-lk的答案。）

Answer 1

有时候了解你的目标是有帮助的：

您需要多种参数类型
并且对于每种参数类型，有几种可能的“值”

并希望在每个值组合上应用一些东西（每次一个参数类型一个）。

看起来可以表达出来：

combine<
    Set<Sha256, Sha512, Sa512_256, Sha3_256, Sha3_512>,
    Set<TwoPassKeyedHash, OnePassKeyedHash, PlainHash>,
    Set<GetLeaf<8>, GetLeaf<1024>>,
    Set<algA, algB, algC>
>(runAndTime);

如果runAndTime是以下的实例：

struct SomeFunctor {
   template <typename H, typename W, typename L, typename A>
   void operator()(cons<H>{}, cons<W>{}, cons<L>{}, cons<A>{});
};

和cons只是一种将类型作为常规参数传递的方法（更容易）。

我们走吧？

首先，一些传递类型的方法（便宜）：

template <typename T>
struct cons { using type = T; };

template <typename... T>
struct Set {};

明确bind（内部没有魔法）：

template <typename F, typename E>
struct Forwarder {
    Forwarder(F f): inner(f) {}

    template <typename... Args>
    void operator()(Args... args) { inner(cons<E>{}, args...); }

    F inner;
}; // struct Forwarder

现在我们深入研究手头的真正任务：

我们需要迭代类型集
在一个集合中，我们需要迭代其元素（类型）

这需要两个级别的调度：

template <typename FirstSet, typename... Sets, typename F>
void combine(F func);

template <typename Head, typename... Tail, typename... Sets, typename F>
void apply_set(F func, Set<Head, Tail...>, Sets... others);

template <typename... Sets, typename F>
void apply_set(F func, Set<>, Sets... others);

template <typename E, typename NextSet, typename... Sets, typename F>
void apply_item(F func, cons<E>, NextSet, Sets...);

template <typename E, typename F>
void apply_item(F func, cons<E> e);

combine是外部（公开）函数，apply_set用于迭代集合，apply_item用于迭代集合中的类型。

实施很简单：

template <typename Head, typename... Tail, typename... Sets, typename F>
void apply_set(F func, Set<Head, Tail...>, Sets... others) {
    apply_item(func, cons<Head>{}, others...);

    apply_set(func, Set<Tail...>{}, others...);
} // apply_set

template <typename... Sets, typename F>
void apply_set(F, Set<>, Sets...) {}

template <typename E, typename NextSet, typename... Sets, typename F>
void apply_item(F func, cons<E>, NextSet ns, Sets... tail) {
    Forwarder<F, E> forwarder(func);

    apply_set(forwarder, ns, tail...);
}

template <typename E, typename F>
void apply_item(F func, cons<E> e) {
    func(e);
} // apply_item


template <typename FirstSet, typename... Sets, typename F>
void combine(F func) {
    apply_set(func, FirstSet{}, Sets{}...);
} // combine

对于apply_set和apply_item中的每一个，我们都有一个递归的情况和一个基本情况，尽管这是apply_item调用回{{1}}的某种共同递归

一个简单的例子：

apply_set

打印you can witness live on Coliru：

struct Dummy0 {}; struct Dummy1 {}; struct Dummy2 {};
struct Hello0 {}; struct Hello1 {};

struct Tested {
    Tested(int i): value(i) {}

    void operator()(cons<Dummy0>, cons<Hello0>) { std::cout << "Hello0 Dummy0!\n"; }
    void operator()(cons<Dummy0>, cons<Hello1>) { std::cout << "Hello1 Dummy0!\n"; }
    void operator()(cons<Dummy1>, cons<Hello0>) { std::cout << "Hello0 Dummy1!\n"; }
    void operator()(cons<Dummy1>, cons<Hello1>) { std::cout << "Hello1 Dummy1!\n"; }
    void operator()(cons<Dummy2>, cons<Hello0>) { std::cout << "Hello0 Dummy2!\n"; }
    void operator()(cons<Dummy2>, cons<Hello1>) { std::cout << "Hello1 Dummy2!\n"; }

    int value;
};

int main() {
    Tested tested(42);
    combine<Set<Dummy0, Dummy1, Dummy2>, Set<Hello0, Hello1>>(tested);
}

享受：）

注意：假定仿函数复制起来很便宜，否则可以使用引用，无论是在传递还是将其存储在Hello0 Dummy0! Hello1 Dummy0! Hello0 Dummy1! Hello1 Dummy1! Hello0 Dummy2! Hello1 Dummy2!时。

修改：删除Forwarder周围的cons（它出现的任何地方），这是不必要的。

Answer 2

除非专业化完成，否则函数不允许部分特化。每个新的不同函数签名都会声明一个新的重载，除非它们的签名完全相同。

请尝试使用以下代码：

#include <iostream>

template<typename Aux_type>
void test_helper()
{}

template<typename Aux_type, typename Head, typename... Tail>
void test_helper() {
   std::cout << Head::i;
   test_helper<Aux_type, Tail...>();
}

template<typename... Args>
void test()
{
    test_helper<void, Args...>();
}

struct A{
   static const int i=1;
};

struct B{
   static const int i=2;
};

int main() {
   test<A, B>();
   return 0;
}

和it does compile（并打印12）。

无论如何，我还没理解你的伪代码样本。

Answer 3

我认为C ++不是正确的工具，当涉及到方便灵活的代码生成时......只需用您选择的脚本语言编写一个简单的实用程序，就像在python中一样：

generate_test_code.py：

#!/usr/bin/python
for HashFuction in {"Sha256", "Sha512", "Sa512_256", "Sha3_256", "Sha3_512"}:
    for KeyingWrapper in {"TwoPassKeyedHash", "OnePassKeyedHash", "PlainHash"}:
        for InstantiatedGetLeaf in {"GetLeaf<8>", "GetLeaf<1024>"}:
            for Algorithm in {"algA", "algB", "algC"}:
                print("runAndTime<{},{},{},{}>(someArgs);".format(HashFuction,KeyingWrapper,InstantiatedGetLeaf,Algorithm))

...然后在你的Makefile中：

generated_test_code.cpp: generate_test_code.py
    python generate_test_code.py > generated_test_code.cpp

...在您的c ++代码中，只需#include“generated_test_code.cpp”即可。

用于循环模板参数/类型

3 个答案: