类型特性
类型特性定义一个编译时基于模板的结构,以查询或修改类型的属性。
试图特化定义于 <type_traits> 头文件的模板导致未定义行为,除了 std::common_type 可依照其所描述特化。
定义于<type_traits>头文件的模板可以用不完整类型实例化,除非另外有指定,尽管通常禁止以不完整类型实例化标准库模板。
杂项变换
推导以一组实参调用一个可调用对象的结果类型
std::result_of,
std::invoke_result
template< class > class result_of; // 不定义 | (1) | (C++11 起) (C++17 中弃用) (C++20 中移除) |
template< class F, class... ArgTypes> | (2) | (C++17 起) |
在编译时推导 INVOKE 表达式的返回类型。
F 必须是可调用类型、到函数引用或到可调用类型的引用。以 ArgTypes... 调用 F 必须是良式表达式。 | (C++11 起) |
F 和 ArgTypes 中的所有类型可以是任何完整类型、未知边界数组或(可有 cv 限定的) void | (C++14 起) |
成员类型
成员类型 | 定义 |
type | 若以参数 ArgTypes... 调用可调用 (Callable) 类型 F 的返回类型。仅若 F 能以参数 ArgTypes... 在不求值语境中调用才得到定义。 (C++14 起) |
辅助类型
template< class T > | (1) | (C++14 起) (C++17 中弃用) (C++20 中移除) |
template< class F, class... ArgTypes> | (2) | (C++17 起) |
可能的实现
namespace detail {
template <class T>
struct is_reference_wrapper : std::false_type {};
template <class U>
struct is_reference_wrapper<std::reference_wrapper<U>> : std::true_type {};
template <class Base, class T, class Derived, class... Args>
auto INVOKE(T Base::*pmf, Derived&& ref, Args&&... args)
-> typename std::enable_if<std::is_function<T>::value &&
std::is_base_of<Base, typename std::decay<Derived>::type>::value,
decltype((std::forward<Derived>(ref).*pmf)(std::forward<Args>(args)...))>::type;
template <class Base, class T, class RefWrap, class... Args>
auto INVOKE(T Base::*pmf, RefWrap&& ref, Args&&... args)
-> typename std::enable_if<std::is_function<T>::value &&
is_reference_wrapper<typename std::decay<RefWrap>::type>::value,
decltype((ref.get().*pmf)(std::forward<Args>(args)...))>::type;
template <class Base, class T, class Pointer, class... Args>
auto INVOKE(T Base::*pmf, Pointer&& ptr, Args&&... args)
-> typename std::enable_if<std::is_function<T>::value &&
!is_reference_wrapper<typename std::decay<Pointer>::type>::value &&
!std::is_base_of<Base, typename std::decay<Pointer>::type>::value,
decltype(((*std::forward<Pointer>(ptr)).*pmf)(std::forward<Args>(args)...))>::type;
template <class Base, class T, class Derived>
auto INVOKE(T Base::*pmd, Derived&& ref)
-> typename std::enable_if<!std::is_function<T>::value &&
std::is_base_of<Base, typename std::decay<Derived>::type>::value,
decltype(std::forward<Derived>(ref).*pmd)>::type;
template <class Base, class T, class RefWrap>
auto INVOKE(T Base::*pmd, RefWrap&& ref)
-> typename std::enable_if<!std::is_function<T>::value &&
is_reference_wrapper<typename std::decay<RefWrap>::type>::value,
decltype(ref.get().*pmd)>::type;
template <class Base, class T, class Pointer>
auto INVOKE(T Base::*pmd, Pointer&& ptr)
-> typename std::enable_if<!std::is_function<T>::value &&
!is_reference_wrapper<typename std::decay<Pointer>::type>::value &&
!std::is_base_of<Base, typename std::decay<Pointer>::type>::value,
decltype((*std::forward<Pointer>(ptr)).*pmd)>::type;
template <class F, class... Args>
auto INVOKE(F&& f, Args&&... args)
-> typename std::enable_if<!std::is_member_pointer<typename std::decay<F>::type>::value,
decltype(std::forward<F>(f)(std::forward<Args>(args)...))>::type;
} // namespace detail
// 最小 C++11 实现:
template <class> struct result_of;
template <class F, class... ArgTypes>
struct result_of<F(ArgTypes...)> {
using type = decltype(detail::INVOKE(std::declval<F>(), std::declval<ArgTypes>()...));
};
// 符合 C++14 的实现(亦为合法的 C++11 实现):
namespace detail {
template <typename AlwaysVoid, typename, typename...>
struct invoke_result { };
template <typename F, typename...Args>
struct invoke_result<decltype(void(detail::INVOKE(std::declval<F>(), std::declval<Args>()...))),
F, Args...> {
using type = decltype(detail::INVOKE(std::declval<F>(), std::declval<Args>()...));
};
} // namespace detail
template <class> struct result_of;
template <class F, class... ArgTypes>
struct result_of<F(ArgTypes...)> : detail::invoke_result<void, F, ArgTypes...> {};
template <class F, class... ArgTypes>
struct invoke_result : detail::invoke_result<void, F, ArgTypes...> {};
输出
#include <type_traits>
#include <iostream>
struct S
{
double operator()(char, int&);
float operator()(int)
{
return 1.0;
}
};
template<class T>
typename std::result_of<T(int)>::type f(T& t)
{
std::cout << "overload of f for callable T" << std::endl;
return t(0);
}
template<class T, class U>
int f(U u)
{
std::cout << "overload of f for non-callable T" << std::endl;
return u;
}
int main()
{
std::cout << std::boolalpha;
// 以 char 和 int 参数调用 S 的结果是 double
std::result_of<S(char, int&)>::type d = 3.14; // d 拥有 double 类型
std::cout << "std::is_same<decltype(d), double>::value: "
<< std::is_same<decltype(d), double>::value << std::endl;
// 以 int 参数调用 S 的结果是 float
std::result_of<S(int)>::type x = 3.14; // x 拥有 float 类型
std::cout << "std::is_same<decltype(x), double>::value: "
<< std::is_same<decltype(x), double>::value << std::endl;
// result_of 能以指向成员函数的指针以如下方式使用
struct C
{
double Func(char, int&);
};
std::result_of<decltype(&C::Func)(C, char, int&)>::type g = 3.14;
std::cout << "std::is_same<decltype(g), double>::value: "
<< std::is_same<decltype(g), double>::value << std::endl;
f<C>(1); // C++11 中可能编译失败; C++14 中调用不可调用重载
return 0;
}