c++ - 转发可从函数指针类型间接推导的参数

Question

我想要一个函数，它接受一个指向函数的指针，并转发函数指针类型本身给定的所有参数，如下所示:

template < typename RET, typename ... ARGS >
auto Do1( RET(*ptr)(ARGS...), ARGS... args )
{
    (*ptr)(std::forward<ARGS>( args )...);
}

int main ()
{
    int i=4;

    Do1( &Ex1, i );
    Do1( &Ex2, i ); //fails!
    Do1( &Ex3, i+1 ); // fails
}

要调用的函数适用于两个示例:

void Ex1( int i){ std::cout << __PRETTY_FUNCTION__ << " " << i << std::endl; i=10;}
void Ex2( int& i){ std::cout << __PRETTY_FUNCTION__ << " " << i << std::endl; i=20;}
void Ex3( int&& i){ std::cout << __PRETTY_FUNCTION__ << " " << i << std::endl; i=30;}

在 Ex2 和 Ex3 的情况下，它失败了，只是因为它尝试推导 ARGS 列表的类型两次，结果不同。编译器提示:

main.cpp:57:22: error: no matching function for call to 'Do1(void (*)(int&), int&)'
         Do1( &Ex2, i ); //fails!
                      ^   
main.cpp:33:10: note: candidate: 'template<class RET, class ... ARGS> auto Do1(RET (*)(ARGS ...), ARGS ...)'
     auto Do1( RET(*ptr)(ARGS...), ARGS... args )
          ^~~ 
main.cpp:33:10: note:   template argument deduction/substitution failed:
main.cpp:57:22: note:   inconsistent parameter pack deduction with 'int&' and 'int'

之后，我尝试使用以下方法解决该问题，因为我仅通过一次推导 ARGS 列表并再次转发到中间 lambda 来获取类型，如下所示:

template < typename RET, typename ... ARGS >
auto Do2( RET(*ptr)(ARGS...) )
{   
    return [ptr]( ARGS ... args )
    {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
        (*ptr)(std::forward<ARGS>(args)...); 
    };
}   

int main ()
{   
    int i=4;

    Do1( &Ex1, i );
    Do1( &Ex2, i ); //fails!
    Do1( &Ex3, i+1 ); // fails

    Do2( &Ex1 )( i );
    std::cout << "now i: " << i << std::endl;
    std::cout << std::endl;

    Do2( &Ex2 )( i );
    std::cout << "now i: " << i << std::endl;
    std::cout << std::endl;

    Do2( &Ex3 )( i+1 );
    std::cout << "now i: " << i << std::endl;
    std::cout << std::endl;
}

问:有什么办法可以修复第一种方法，在任何情况下都可以去掉这里的中间 lambda？如果没有，中间 lambda 的解决方案是否设计得“很好”，尤其是所有“转发”的东西，这样我就不会创建一些拷贝或其他意外行为？

编辑:这只是一个简化的例子。我不打算编写 std::invoke 的拷贝。所以在我的真实世界代码中，Do 方法本身还有很多事情要做。

从函数指针类型中获取所需的类型很重要，因为我必须在 Do 中执行一些检查，这些检查与函数指针提供的类型相关，不 从我从用户代码提供给 Do 方法的给定附加参数。

Answer 1

Q: Is there any way to repair the first approach in any case to get rid of the intermediate lambda here?

我建议接受可调用的 ptr 简单地作为一个类型

template < typename F, typename ... ARGS >
auto Do1( F func, ARGS && ... args )
 {
    func(std::forward<ARGS>( args )...);
 }

这样你的 Do1() 就完全避免了双重不同的推导问题并且也适用于其他类型的可调用对象(例如:使用不能简单地转换为函数指针的通用 lambda) .

否则你可以拦截两个参数类型的可变列表

template < typename RET, typename ... AS1, typename ... AS2 >
auto Do1( RET(*ptr)(AS1...), AS2 && ... args )
 {
   (*ptr)(std::forward<AS2>( args )...);
 }