Question

我正在用C ++编写一个程序，我应该将不同的函数嵌入到同一个for循环中。

示例：

for(i = 0; i < N_ITER; i++) {
    /* ... */
    function_A(); 
    /* ... */
}

for(i = 0; i < N_ITER; i++) {
    /* ... */
    function_B(); 
    /* ... */
}

出于性能考虑，我必须将function_A和function_B 内联到此函数中。我的第一个解决方案是使用Functors和函数模板，如下所示：

class function_A {
public:
    void operator()() {
        /* ... */   
    }
};

class function_B {
public:
    void operator()() {
        /* ... */
    }
};

template <class T>
class run {
public:
    void operator()() {
        /* ... */
        T func;
        for (i = 0; i < N_ITER; i++) {
            /* ... */
            func();
            /* ... */
        }
        /* ... */
    }
};

我可以调用以下函数：

run<function_A>()();
run<function_B>()();

但很快我发现在代码中有太多重复的函子定义class xxx { public: void operator()() {...} };，它看起来很尴尬。

所以我使用lambda变成了一个解决方案：

auto function_A = []()
{
    /* ... */
};

auto function_B = []()
{
    /* ... */
};

template <class T>
class run {
public:
    T func;
    run(T func) : func(func) {}
    void operator()() {
        /* ... */
        for (i = 0; i < N_ITER; i++) {
            /* ... */
            func();
            /* ... */
        }
        /* ... */
    }
};

但是这一次调用这些函数更难：

run<decltype(function_A)> funcA(function_A); funcA();
run<decltype(function_A)> funcB(function_A); funcB();

并不像以前的解决方案那样清晰。

有一种更优雅的方式在C ++中实现它吗？我错过了什么吗？任何建议将不胜感激!!!

Answer 1

试试这个：

void run(std::function<void(void)> fn)
{
    for (int i = 0; i < N_ITER; i++)
        fn();
}

(...)

auto lambda1 = []()
    {
        std::cout << "Hello, world!\n";
    };

run(lambda1);

准备好run函数/方法之后，您也可以这样做：

class C
{
public:
    void operator()()
    {
        printf("Hello world from a functor!\n");
    }
};

(...)

C c;

run(c);

编辑：回复评论：

以前的解决方案没有内联。但是，这是：

template <typename T>
void run2(T fn)
{
    for (int i = 0; i < 10; i++)
        fn();
}

int main(int argc, char * argv[])
{
    getchar();

    auto lambda1 = []()
        {
            std::cout << "Hello, world!\n";
        };

    run2(lambda1);

    getchar();
}

拆卸：

        auto lambda1 = []()
            {
                std::cout << "Hello, world!\n";
            };

        run2(lambda1);
002E1280  mov         ecx,dword ptr ds:[2E3044h]  
002E1286  call        std::operator<<<std::char_traits<char> > (02E1730h)  
002E128B  dec         esi  
002E128C  jne         main+10h (02E1280h)

实际上，在运行2的情况下使用仿函数的解决方案也被内联了，但是稍长一点：

    C c;

    run2(c);
01031293  mov         esi,0Ah  
01031298  jmp         main+30h (010312A0h)  
0103129A  lea         ebx,[ebx]  
010312A0  mov         ecx,dword ptr ds:[1033044h]                          \
010312A6  mov         edx,10331ACh                                         |
010312AB  call        std::operator<<<std::char_traits<char> > (01031750h)  > loop 
010312B0  dec         esi                                                  |
010312B1  jne         main+30h (010312A0h)                                 /

Answer 2

关于你的关注

但很快我发现有太多重复的算子定义代码中的class xxx { public: void operator()() {...} };，它看起来别扭。

你可能不应该写

class function_B {
public:
    void operator()() {
        /* ... */
    }
};

但带有struct的版本可以保存一行语法杂乱（public:），因为结构的成员默认为public：

struct function_B {
    void operator()() {
        /* ... */
    }
};

实际上，IMO与简单的函数声明相比，开销相当小。

当然，lambda版本少了一点combined with a free templeate function，你也不需要decltype。

WRT。对于lambda解决方案，还必须考虑到可以将struct的整个定义放入头文件中，而不能放置定义如果从多个翻译单元使用该头文件，则在头文件中使用lambda object 。

当然，如上所述的问题看起来很像这些定义很可能写在cpp文件中，因此lambda解决方案可能同样适用。

在函数中嵌入不同的函数：functor或lambda？

2 个答案: