如何使用参数值（仅在运行时已知）调用函数（仅在运行时已知）？

Question

在运行时进行单个测试以确定调用两个函数中的哪一个，并确定参数值。

然后每隔几秒调用一次该函数。

void Foo::func( std::string s);
void Foo::func( std::string s1 std::string s2, std::string s2);

显然，每次调用都测试（调用哪个函数）效率低下，尤其是当函数及其参数值一旦建立就不会改变时。

我需要这样的东西：

测试一次调用哪个函数并建立参数值。

将初始化函数分配给某种可调用变量。

funcVar = void Foo::func( "blah", "blah", "woof" );

或

funcVar = void Foo::func( "blah" );

然后调用函数；

for( every few seconds )
{
call FuncVar;
}

我可以使用某种可调用变量来执行此操作吗？

Answer 1

您可以使用 std::bind 为您的两个用例创建具有存储参数和通用调用运算符的仿函数。检查此代码段：

#include <string>
#include <functional>

struct Foo {
    static void a(std::string) {}
    static void b(std::string, std::string) {}
};

int main() {
    std::function<void()> x;

    if(true) {
        x = std::bind(&Foo::b, "a", "b");
    }

    x();

    return 0;
}

Answer 2

您可以简单地使用一个 lambda 函数对象（闭包），您可以随意调用它。

示例：

struct Foo 
{
    void func( std::string s){ std::cout << "single" << s << std::endl; };
    void func( std::string s1, std::string s2, std::string s3) 
    {   
        std::cout << "tripple " << s1 << " " << s2 << " " << s3 << std::endl;
    }   

    // Select which function to call
    std::function<void()> Select( int what )
    {   
        if ( what == 1 )
        {   
            // Create a callable object and put in also parameters
            return [this]() { func("Hallo"); };
        }
        else
        {   
            // The same for the other selection
            return [this]() { func("This","is","tripple!"); };
        }
    }   
};  

int main()
{   
    Foo foo;
 
    // Pick what you want to select
    auto action = foo.Select( 2 );

    for ( ;; )
    {   
        // and call it as often you like
        action();
    }   
}

Answer 3

如果要std::bind重载函数，必须指定要使用的函数：

#include <string>
#include <functional>
#include <iostream>
#include <map>


struct Foo {
    void b() { std::cout << name << ": function 1" << std::endl; }
    void b(int i) {std::cout << name << ": function 2" << std::endl; }

    std::string name;
};


void with_map() {
    Foo f;
    f.name = "with_map";

    std::map<const int, std::function<void()>> map({
        {10, std::bind<void(Foo::*)(), Foo&>(&Foo::b, f)},
        {20, std::bind<void(Foo::*)(int), Foo&, int>(&Foo::b, f, 1)},
    });

    map[20]();
    map[10]();
}


void without_map() {
    Foo f;
    f.name = "without_map";

    std::function<void()> x = std::bind<void(Foo::*)(), Foo&>(&Foo::b, f);
    x();

    x = std::bind<void(Foo::*)(int), Foo&, int>(&Foo::b, f, 1);
    x();
}


int main() {

    without_map();

    with_map();

    return 0;
}

Answer 4

std::function 应该在这里工作。

std:: function<void()> fun = [&s] () {/* do  work*/};
if (some_condition)
{
   fun = [&s1,&s2,&s3] () {/* do your work*/} ;
}

if(every few seconds)
{
    fun();
}

如何使用参数值（仅在运行时已知）调用函数（仅在运行时已知）？

How to call a function(only known at runtime) with parameter values(only known at runtime)?

c++

call

std-function