这不会编译function_type_deducer([](){}).describe_me();
如果function_type_deducer不是模板，它会起作用。:) 非捕获 lambda（空[]）可隐式转换为函数指针。遗憾的是，某些模板参数推导没有考虑隐式转换。有关更多信息，请参阅此问题（请注意，我的回答并不完全正确，如评论所示）。
它没有注意到 x 和 y 之间有一个小的区别，因为 y 接受一个字符串&，其中 x 接受一个字符串。
这不是函数的问题，而是 的问题typeid，正如这个简单的测试代码所示：
template<class T>
void x(void(T)){
T v;
(void)v;
}
void f1(int){}
void f2(int&){}
int main(){
x(f1);
x(f2);
}
Ideone 上的实时示例。输出：
错误：“v”声明为引用但未初始化
一个简单的修复可能是使用标签调度：
#include <type_traits> // is_reference
#include <iostream>
#include <typeinfo>
template<class T>
void print_name(std::true_type){
std::cout << "reference to " << typeid(T).name();
}
template<class T>
void print_name(std::false_type){
std::cout << typeid(T).name();
}
template<class T>
void print_name(){
print_name(typename std::is_reference<T>::type());
}
并调用print_name<NextArg>()而不是typeid(NextArg).name().
我重新发明了轮子吗？
是的，有点，不，你没有。Boost.Function为所有参数（argN_type样式）提供类型定义，以及arity为其数量提供静态常量。但是，您不能轻松地访问这些类型定义。您将需要一种迂回的方式来避免意外访问不存在的方式。这个tuple想法效果最好，但是可以用更好的方式编写。这是我曾经写过的东西的修改版本：
#include <tuple>
#include <type_traits>
#include <iostream>
#include <typeinfo>
namespace detail{
template<class T>
std::ostream& print_name(std::ostream& os);
template<class T>
std::ostream& print_pointer(std::ostream& os, std::true_type){
typedef typename std::remove_pointer<T>:: type np_type;
os << "pointer to ";
return print_name<np_type>(os);
}
template<class T>
std::ostream& print_pointer(std::ostream& os, std::false_type){
return os << typeid(T).name();
}
template<class T>
std::ostream& print_name(std::ostream& os, std::true_type){
return os << "reference to " << typeid(T).name();
}
template<class T>
std::ostream& print_name(std::ostream& os, std::false_type){
return print_pointer<T>(os, typename std::is_pointer<T>::type());
}
template<class T>
std::ostream& print_name(std::ostream& os){
return print_name<T>(os, typename std::is_reference<T>::type());
}
// to workaround partial function specialization
template<unsigned> struct int2type{};
template<class Tuple, unsigned I>
std::ostream& print_types(std::ostream& os, int2type<I>){
typedef typename std::tuple_element<I,Tuple>::type type;
print_types<Tuple>(os, int2type<I-1>()); // left-folding
os << ", ";
return print_name<type>(os);
}
template<class Tuple>
std::ostream& print_types(std::ostream& os, int2type<0>){
typedef typename std::tuple_element<0,Tuple>::type type;
return print_name<type>(os);
}
} // detail::
template<class R, class... Args>
struct function_info{
typedef R result_type;
typedef std::tuple<Args...> argument_tuple;
static unsigned const arity = sizeof...(Args);
void describe_me(std::ostream& os = std::cout) const{
using namespace detail;
os << "I return '"; print_name<result_type>(os);
os << "' and I take '" << arity << "' arguments. They are: \n\t'";
print_types<argument_tuple>(os, int2type<arity-1>()) << "'\n";
}
};
Ideone 上的实时示例。输出：
main: I return 'i' and I take '2' arguments. They are:
'i, pointer to pointer to c'
x: I return 'Ss' and I take '3' arguments. They are:
'i, Ss, c'
y: I return 'Ss' and I take '3' arguments. They are:
'i, reference to Ss, c'