Question

我希望每个功能都能完成两次。参数在数组中，所以它是这样的：

fun1(A[0]);
fun1(A[1]);

fun2(A[0]);
fun2(A[1]);

fun3(A[0]);
fun3(A[1]);

有没有办法自动完成？我不能用

for(int i=0; i<2; i++)

因为它将是：

fun1(A[0]);
fun2(A[0]);
fun3(A[0]);

fun1(A[1]);
fun2(A[1]);
fun3(A[1]);

在这种情况下命令很重要。

Answer 1

您可以使用函数指针遍历要在容器中的每个元素上调用的所有函数。例如

#include <iostream>
#include <vector>

void fun1(int i)
{
    std::cout << "fun1: " << i << "\n";
}

void fun2(int i)
{
    std::cout << "fun2: " << i << "\n";
}

int main()
{
    using fn_t = void(*)(int);
    std::vector<fn_t> funs{&fun1, &fun2};
    std::vector<int> A = {2, 5};

    for (auto& f : funs)
    {
        for (int i : A)
        {
            f(i);
        }
    }
}

Output

fun1: 2
fun1: 5
fun2: 2
fun2: 5

Answer 2

这是一个用于存储函数数组的C版本（忽略std命名空间），以防您无法使用@CoryKramer提供的解决方案。

typedef void (*PointerFunction)(int x);

void functA(int a) {
    std::cout << "functA: " << a << std::endl;
}
void functB(int b) {
    std::cout << "functB: " << b << std::endl;
}

PointerFunction functions[] = { functA, functB };

for (int func = 0; func < 2; func++) {
    for (int i = 0; i < 2; i++) {
        functions[func](i);
    }
}

Answer 3

您可以将该行为包含在应用函数两次的高阶函数中，并将该函数应用于函数。

使用C ++ 17折叠表达式可以看起来像

一样简单

template <typename Func, typename Arr, typename... Indices>
void map_indices(Func&& f, Arr&& arr, Indices&&... is) {
  (f(arr[is]), ...);
}

使用C ++ 11或C ++ 14可以使用递归来实现。

您的示例将如下所示

#include <array>
#include <iostream>

template <typename Func, typename Arr, typename... Indices>
void map_indices(Func&& f, Arr&& arr, Indices&&... is) {
  (f(arr[is]), ...);
}

void f1(int x) {
  std::cout << "f1 " << x << '\n';
}

void f2(int x) {
  std::cout << "f2 " << x << '\n';
}

void f3(int x) {
  std::cout << "f3 " << x << '\n';
}

int main() {
  std::array arr{1, 2, 3};
  map_indices(f1, arr, 0, 1);
  map_indices(f2, arr, 0, 1);
  map_indices(f3, arr, 0, 1);
}

如果您知道您只需要索引0和1 map_indices可以简化为

template <typename Func, typename Arr>
void map_indices(Func&& f, Arr&& arr) {
  f(arr[0]);
  f(arr[1]);
}

每次操作两次

3 个答案: