c++ - c++-17特化模式匹配中lambda的拆分函数签名

Question

我有以下代码:

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

template<typename T> struct tag {};                                                                                                         

template <typename LambdaType, typename=void>                                                                                               
struct split {                                                                                                                              
    split(LambdaType &&f) {                                                                                                                 
        std::cout << "[]()" << std::endl;                                                                                                   
    }                                                                                                                                       
};                                                                                                                                          

template <typename RetType, typename... ArgTypes>                                                                                           
struct split<std::function<RetType(ArgTypes...)>>  {                                                                                        
    split(std::function<RetType(ArgTypes...)> &&f) {                                                                                        
        std::cout << "std::function" << std::endl;                                                                                          
    };                                                                                                                                      
};                                                                                                                                          

template <typename RetType, typename... ArgTypes>                                                                                           
struct split<RetType(*)(ArgTypes...)> {                                                                                                     
    split(RetType(*f)(ArgTypes...)) {                                                                                                       
        std::cout << "func-ptr" << std::endl;                                                                                               
    };                                                                                                                                      
};                                                                                                                                          

void f1(int) {};                                                                                                                            

int                                                                                                                                         
main(int argc, char **argv) {                                                                                                               

    new split<std::decay<decltype(f1)>::type>(f1);                                                                                          
    new split<std::function<void(int)>>(std::function<void(int)>([](int) {}));                                                              

    /* how can I extract the argument type template pack from lambda ? */                                                                   
    new split([](int){});                                                                                                                   
    return 0;                                                                                                                               
}   

split 有 2 个特化, 一个用于 std::function<RetType(ArgTypes...)>和一个 RetType(*)(ArgTypes...) .对于这两个专业，我都得到了 RetType和 ArgTypes...模板参数并通过模式匹配进行打包。但是我想知道是否有某种方法可以对 lambda 做同样的事情作为参数？

如何提取 RetType和 ArgTypes... new split([](int){}) 特化中的 lambda线 ？

Answer 1

您可以将模板类参数推导与 std::function 一起使用:

template <typename LambdaType, typename=void>                                                                                               
struct split {                                                                                                                              
    using StdFunctionType = decltype(std::function{std::declval<LambdaType>()});                                                                                                                                  
};     

一旦你有了 std::function对应于您的 lambda，您可以使用模板特化检索返回和参数类型。

这是有效的，因为 std::function有一个deduction guide :

template<class F>
function(F) -> function</*see below*/>;

If decltype(&F::operator()) is of the form R(G::*)(A...) (optionally cv-qualified, optionally noexcept, optionally lvalue reference qualified) for some class type G, then the deduced type is std::function<R(A...)>. This overload only participates in overload resolution if &F::operator() is well-formed when treated as an unevaluated operand.