当前位置：首页 > news >正文

萃取的实现（三）

news 来源：原创 2025/9/20 16:29:25

探测成员

基于SFINAE，判断一个给定类型T，是否含有名为x的成员。

探测类型成员

判断一个给定类型T，是否含有类型成员size_type，源码如下：

#include <type_traits>
#include <iostream>
#include <vector>template <typename ...>
using void_t = void;template <typename , typename = void_t<>>
struct has_sizetype_t : std::false_type {};template <typename T>
struct has_sizetype_t<T, void_t<typename T::size_type>> : std::true_type {};int main(int argc, char **argv) {std::cout << (has_sizetype_t<int>::value ? "true" : "false") << std::endl;std::cout << (has_sizetype_t<std::vector<int>>::value ? "true" : "false") << std::endl;return 0;
}

注意：如果类型成员为private成员，萃取模板没有访问该类型的特殊权限，has_sizetype_t会返回false。

对于普通类型，上述模板能够准确做出判断，但如果模板参数为引用类型，如std::vector<int>&，上述模板处理结果确是false。为了能兼容这种情况，可以在偏特化使用std::removereference，如下：

template <typename T>
struct has_sizetype_t<T, void_t<typename std::remove_reference<T>::type::size_type>> : std::true_type {};

对于注入类的名字，上述检测模板也会返回true，如下：

struct size_type {};
struct size_able : size_type {};//...
std::cout << (has_sizetype_t<size_able>::value ? "true" : "false") << std::endl;

探测任意类型成员

has_sizetype_t能够有效的判断一个类型T是否包含类型成员size_type，如果把size_type换成其他类型呢？最简单也是最暴力的做法，就是仿照has_sizetype_t再实现一个萃取模板。但为每个类型成员都实现一个萃取模板，不太合理，把类型成员参数化，才是最优的选择。然而不幸的是，目前还没有语言机制可以被用来描述“潜在” 的名字。但是可以通过宏来实现这一功能，源码如下：

#include <type_traits>
#include <iostream>
#include <string>
#include <vector>template <typename ...>
using void_t = void;#define define_has_member_type(member_type) \template <typename , typename = void_t<>> \struct has_##member_type##_t : std::false_type {}; \\template <typename T> \struct has_##member_type##_t<T, void_t<typename std::remove_reference<T>::type::member_type>> : std::true_type {};//struct has_##member_type##_t<T, void_t<typename T::member_type>> : std::true_type {};define_has_member_type(size_type)
define_has_member_type(str_type)class mystring {
public:using str_type = std::string;
};class myint {
public:using int_type = int;
};int main(int argc, char **argv) {std::cout << (has_str_type_t<mystring&&>::value ? "true" : "false") << std::endl;std::cout << (has_str_type_t<myint>::value ? "true" : "false") << std::endl;std::cout << (has_size_type_t<int>::value ? "true" : "false") << std::endl;std::cout << (has_size_type_t<std::vector<int>>::value ? "true" : "false") << std::endl;std::cout << (has_size_type_t<std::vector<int>&&>::value ? "true" : "false") << std::endl;return 0;
}

探测非类型成员

对上述萃取模板做简单的修改，便可以得到探测非类型成员的萃取模板，如下：

#include <type_traits>
#include <iostream>template <typename ...>
using void_t = void;#define define_has_member(member) \template <typename, typename = void_t<>> \struct has_##member##_t : std::false_type {}; \\template <typename T> \struct has_##member##_t<T, void_t<decltype(&T::member)>> : std::true_type {};enum myenum {failed = 0,succeeded = 1
};class myclass {
public:int value;myenum status;static int instance_number;
};class myclass2 {
public:using status = myenum;
};define_has_member(value)
define_has_member(status)
define_has_member(instance_number)int main(int argc, char **argv) {std::cout << (has_status_t<myclass2>::value ? "true" : "false") << std::endl;std::cout << (has_status_t<std::true_type>::value ? "true" : "false") << std::endl;std::cout << (has_value_t<myclass>::value ? "true" : "false") << std::endl;std::cout << (has_status_t<myclass>::value ? "true" : "false") << std::endl;std::cout << (has_instance_number_t<myclass>::value ? "true" : "false") << std::endl;return 0;
}

偏特化模板参数中为什么使用void_t<decltype(&T::member)>，而非void_t<decltype(T::member)>？因为使用后者探测数据成员没有问题，但探测成员函数就无能为力了。使用该萃取模板，还需要注意以下几点：

成员必须是非类型成员以及非枚举成员，否则&T::member失效，所以has_kind_type_t，has_ultrasonic_t均检测失败
成员必须是public成员
member必须没有歧义，对于has_kind_t<bat>::value，has_name_t<bat>::value，has_move_t<bat>::value，编译其无法确认kind为mammals::kind，还是bird::kind，name为mammals::name，还是bird::name，move为mammals::move，还是bird::move，所以均检测失败
如果存在重载函数，检测失败，如bat拥有两个search版本，所以has_search_t检测失败

针对重载函数探测失效的问题，目前的方案只能针对不同的函数实现不同的的萃取模板。如下：

template <typename, typename = void_t<>>
struct has_search_void_t : std::false_type {};template <typename T>
struct has_search_void_t<T, void_t<decltype(std::declval<T>().search())>> : std::true_type {};template <typename, typename = void_t<>>
struct has_search_int_t : std::false_type {};template <typename T>
struct has_search_int_t<T, void_t<decltype(std::declval<T>().search(0))>> : std::true_type {};

下面是两种失败的尝试方案：

//方案1
//ERROR:
//: error: expected ')'
//    std::cout << (has_search_t<bat, int>(nullptr)::value ? "true" : "false") << std::endl;
//to match this '('
//    std::cout << (has_search_t<bat, int>(nullptr)::value ? "true" : "false") << std::endl;
template <typename T, typename ...Args, typename = void_t<decltype(std::declval<T>().search(std::declval<Args>()...))>>
constexpr std::true_type has_search_t(void *);template <typename, typename ...Args>
constexpr std::false_type has_search_t(...);//...
std::cout << (has_search_t<bat, int>(nullptr)::value ? "true" : "false") << std::endl;//方案2
//ERROR：
//template parameter pack must be the last template parameter
//    template <typename, typename ...Args, typename = void_t<>>
//error: expected expression
//    struct has_search_t <T, ...Args, void_t<decltype(std::declval<T>().search(std::declval<Args>()...))>>: std::true_type {};
//expected unqualified-id
//    struct has_search_t <T, ...Args, void_t<decltype(std::declval<T>().search(std::declval<Args>()...))>>: std::true_type {};
template <typename, typename = void_t<>>
struct has_search_void_t : std::false_type {};template <typename T>
struct has_search_void_t<T, void_t<decltype(std::declval<T>().search())>> : std::true_type {};

除了类的类型成员，变量成员，函数成员外，还可以用于探测表达式，甚至是多个表达式的组合，下面是两个例子：

template <typename ...>
using void_t = void;//表达式
template <typename, typename, typename = void_t<>>
struct has_less_t : std::false_type {};template <typename T1, typename T2>
struct has_less_t<T1, T2, void_t<decltype(std::declval<T1>() < std::declval<T2>())>> : std::true_type {};//表达式组合
template <typename, typename = void_t<>>
struct has_calc_t : std::false_type {};template <typename T>
struct has_calc_t<T, void_t<decltype(std::declval<T>() + std::declval<T>(), std::declval<T>() - std::declval<T>(), std::declval<T>() * std::declval<T>(), std::declval<T>() / std::declval<T>())>> : std::true_type {};

用泛型 Lambda 探测成员

使用萃取的实现（二）【将泛型 Lambdas 用于 SFINAE】中的lambda表达式，也可以实现成员探测，源码如下：

constexpr auto has_size_type = is_valid([](auto &&x)->typename std::decay_t<decltype(x)>::size_type {});
template <typename T>
using has_size_type_t = decltype(has_size_type(std::declval<T>()));constexpr auto has_begin = is_valid([](auto &&x)->decltype(x.begin()){});
//constexpr auto has_begin = is_valid([](auto &&x)->decltype(std::declval<decltype(x)>().begin()){});
template <typename T>
using has_begin_t = decltype(has_begin(std::declval<T>()));int main(int argc, char **argv) {std::cout << (has_size_type_t<std::string>::value ? "true" : "false") << std::endl;std::cout << (has_size_type_t<int>::value ? "true" : "false") << std::endl;std::cout << (has_begin_t<std::string>::value ? "true" : "false") << std::endl;std::cout << (has_begin_t<int>::value ? "true" : "false") << std::endl;return 0;
}

其它的萃取技术

If-Then-Else

如何根据数值的大小，自动选择合适的整型类型？首先定义一个模板if_then_else模拟选择行为，该模板接收三个模板参数，并且第一个参数为bool常量表达式，剩余的两个参数为类型参数，由第一个参数的值决定哪个类型参数生效；然后，定义一个参数为整型数值的模板，调用if_then_else，推断出合适的类型（由于实现不知道数值的合适类型，因此模板参数的类型使用了auto，需要c++17才能支持）。代码如下：

template <bool COND, typename TrueType, typename FalseType>
struct if_then_else { using type = TrueType; };template <typename TrueType, typename FalseType>
struct if_then_else<false, TrueType, FalseType> { using type = FalseType; };template <auto N>
struct small_int {using type = typename if_then_else<N <= std::numeric_limits<char> ::max(), char,typename if_then_else<N <= std::numeric_limits<short> ::max(), short,typename if_then_else<N <= std::numeric_limits<int> ::max(), int,typename if_then_else<N <= std::numeric_limits<long>::max(), long,typename if_then_else<N <= std::numeric_limits<long long>::max(), long long,void>::type>::type>::type>::type>::type;
};

需要注意的是，和常规的 C++ if-then-else 语句不同，在最终做选择之前，then 和 else 分支中的模板参数都会被计算，因此两个分支中的代码都不能有问题，否则整个程序就会有问题。

探测不抛出异常的操作

有时候我们需要判断一些操作是否会抛出异常，这时我们需要用到noexcept操作符，该操作符对表达式进行编译时检查，如果表达式不抛出任何异常返回true，否则返回false。主要应用场景如下：

显示指明函数是否会抛出异常：noexcept和noexcept(true)等效，表示该函数不抛出任何异常；noexcept(false)表示有可能抛出异常
阻止异常传播和扩散，出现异常直接调用std::terminate终止进程

#include <iostream>void func1() {throw 1;
}void func2() {func1();
}void func3() noexcept {func1();
}int main(int argc, char **argv) {try {func1();} catch(...) {std::cout << "func1" << std::endl;}try {func2();} catch(...) {std::cout << "func2" << std::endl;}try {func3(); //阻止异常传播，程序crash} catch(...) {std::cout << "func3" << std::endl;}return 0;
}

用于模板，增强c++泛型能力

#include <type_traits>
#include <iostream>template <typename T, typename = std::void_t<>>
struct has_noexcept_move_constructor : std::false_type {};template <typename T>
struct has_noexcept_move_constructor<T, std::void_t<decltype(T(std::declval<T>()))>> : std::bool_constant<noexcept(T(std::declval<T>()))> {};class A {
public:A(A &&) {throw 1;}
};class B {
public:B(B &&) = default;
};int main(int argc, char **argv) {std::cout << (has_noexcept_move_constructor<A>::value ? "true" : "false") << std::endl;std::cout << (has_noexcept_move_constructor<B>::value ? "true" : "false") << std::endl;return 0;
}

萃取的便捷性

关于萃取最大的问题便是繁琐，对于萃取类型的使用需要添加::type后缀，而且在依赖上下文中，还需要一个typename前缀，例如：

template <typename T>
void print_type_name() {std::cout << typeid(typename std::remove_reference<T>::type).name() << std::endl;
}

别名模板和萃取

使用using创建别名，可以简化类型名称，如下：

template <typename T>
using rmref = typename std::remove_reference<T>::type;template <typename T>
void print_type_name() {std::cout << typeid(rmref<T>).name() << std::endl;
}

从c++14开始，直接为之引入了相应的别名模板，以_t结尾，对于“typename std::remove_reference<T>::type”，其别名为“std::remove_reference_t<T>”。

变量模板和萃取

对于返回数值的萃取需要使用一个::value来生成萃取的结果，如下：

template <typename T1, typename T2>
void print_diff() {std::cout << (std::is_same<T1, T2>::value ? "true" : "false") << std::endl;
}

针对上面这种情况，可以使用constexpr修饰的变量模板进行简化（需要在C++14之后），如下：

template <typename T1, typename T2>
constexpr bool issame = std::is_same<T1, T2>::value;template <typename T1, typename T2>
void print_diff() {std::cout << (issame<T1, T2> ? "true" : "false") << std::endl;
}

从c++17开始，直接引入了与之对应的变量模板，以_v结尾，对于“std::is_same<T1, T2>::value”，对应的变量模板为“std::is_same_v<T1, T2>”。

类型分析

判断基础类型

判断一个类型是否是基础类型，如int是否是基础类型。代码如下：

template <typename T>
struct is_fundamental : std::false_type {};template <>
struct is_fundamental<int> : std::true_type {};template <>
struct is_fundamental<double> : std::true_type {};int main(int argc, char **argv) {std::cout << (is_fundamental<double>::value ? "true" : "false") << std::endl;std::cout << (is_fundamental<int>::value ? "true" : "false") << std::endl;return 0;
}

为了能够正确的识别出每一个基础类型，只能针对每个基础类型实现一遍is_fundamental。通过宏尽管能少些一些代码，但本质上依旧是对基础类型的穷举。

#define IS_FUNDAMENTAL(T) template <> struct is_fundamental<T> : std::true_type {};IS_FUNDAMENTAL(float)
IS_FUNDAMENTAL(unsigned long)

判断复合类型

复合类型是由其它类型构建出来的类型。简单的复合类型包含指针类型，左值以及右值引用类型，指向成员的指针类型(pointer-to-member types)，和数组类型。

//指针
template <typename T>
struct is_pointer : std::false_type {};
template <typename T>
struct is_pointer<T *> : std::true_type {};//左值引用
template <typename T>
struct is_lvalue_reference : std::false_type {};
template <typename T>
struct is_lvalue_reference<T &> : std::true_type {};//右值引用
template <typename T>
struct is_rvalue_reference : std::false_type {};
template <typename T>
struct is_rvalue_reference<T &&> : std::true_type {};//数组
template <typename T>
struct is_array : std::false_type {};
template <typename T>
struct is_array<T[]> : std::true_type {};
template <typename T, std::size_t N>
struct is_array<T[N]> : std::true_type {};//指向成员的指针
template <typename T>
struct is_member_pointer : std::false_type {};
template <typename T, typename C>
struct is_member_pointer<T C::*> : std::true_type {};struct S {int a = 10;int b = 20;float func1(void) { return 0; }float func2(void) { return 1; }
};using mem_data_ptr_t = int S::*;
using mem_func_ptr_t = float S::*;int main(int argc, char **argv) {std::cout << (is_pointer<int>::value ? "true" : "false") << std::endl;std::cout << (is_pointer<int *>::value ? "true" : "false") << std::endl;int *pi = &argc;std::cout << (is_pointer<decltype(pi)>::value ? "true" : "false") << std::endl;std::cout << std::endl;std::cout << (is_lvalue_reference<int>::value ? "true" : "false") << std::endl;std::cout << (is_lvalue_reference<int &>::value ? "true" : "false") << std::endl;int &lri = argc;std::cout << (is_lvalue_reference<decltype(lri)>::value ? "true" : "false") << std::endl;std::cout << std::endl;std::cout << (is_rvalue_reference<int>::value ? "true" : "false") << std::endl;std::cout << (is_rvalue_reference<int &&>::value ? "true" : "false") << std::endl;std::cout << (is_rvalue_reference<decltype(std::list<int>())>::value ? "true" : "false") << std::endl;//不太确定为什么decltype(std::list<int>())得到的就不是右值引用类型std::cout << typeid(decltype(std::list<int>())).name() << std::endl;std::list<int> li;std::cout << (is_rvalue_reference<decltype(std::move(li))>::value ? "true" : "false") << std::endl;std::cout << typeid(decltype(std::move(li))).name() << std::endl;std::cout << std::endl;std::cout << (is_array<int>::value ? "true" : "false") << std::endl;std::cout << (is_array<int[]>::value ? "true" : "false") << std::endl;std::cout << (is_array<int [3]>::value ? "true" : "false") << std::endl;int arr[10]; //int arr[0]; decltype(arr)得到的类型时A0_i,不是数组std::cout << (is_array<decltype(arr)>::value ? "true" : "false") << std::endl;std::cout << typeid(int[3]).name() << std::endl;std::cout << typeid(decltype(arr)).name() << std::endl;std::cout << std::endl;using mem_string_ptr_t = std::string S::*;//虽然这个类型不存在，但结果依然返回了true，标注库意识如此std::cout << (is_member_pointer<mem_string_ptr_t>::value ? "true" : "false") << std::endl;std::cout << (is_member_pointer<mem_data_ptr_t>::value ? "true" : "false") << std::endl;std::cout << (is_member_pointer<mem_func_ptr_t>::value ? "true" : "false") << std::endl;}

识别函数类型

在讨论如何识别函数类型时，先考虑如何定义一个函数类型。下面是函数类型定义的相关代码：

#include <iostream>int func_instance(int arg) {std::cout << arg << std::endl;return 0;
}int main(int argc, char **argv) {typedef int (func_t)(int);func_t *func1 = func_instance; ✅func1(12);typedef int (*func_pt)(int);func_pt func2 = func_instance; ✅func2(14);return 0;
}

通过上面的例子，可以看出：只要不同函数类型的返回值和入参一致，既可以表示同一个类型，名称不是特别重要。因此，识别函数类型时，只用到了返回值和入参，只要类型符合Ret(Args...)格式，该类型就是函数类型。这个格式很像去掉了名称的函数类型定义。下面是函数类型识别源码：

#include <type_traits>
#include <iostream>
#include <cstdio>template <typename T>
struct is_function : std::false_type { constexpr static int flag = 0; };template <typename Ret, typename ...Args>
struct is_function<Ret(Args...)> : std::true_type { constexpr static int flag = 1; };template <typename Ret, typename ...Args>
struct is_function<Ret(Args..., ...)> : std::true_type { constexpr static int flag = 2; };class A {
public:A(){}static A &GetInstance() { static A _inst; return _inst; }void Set(int) {}int Get(void) const { return 0; }int Func(int a) const & { return a; }
};struct B
{static int foo();int fun() const&;
};int main(int argc, char **arg) {std::cout << (is_function<int(int)>::value ? "true" : "false") << " " << is_function<int(int)>::flag << std::endl;std::cout << (is_function<decltype(printf)>::value ? "true" : "false") << " " << is_function<decltype(printf)>::flag << std::endl;std::cout << (is_function<decltype(&A::Set)>::value ? "true" : "false") << " " << is_function<decltype(&A::Set)>::flag << std::endl;std::cout << (is_function<const int(void)>::value ? "true" : "false") << " " << is_function<const int(void)>::flag << std::endl;std::cout << (is_function<decltype(&A::Get)>::value ? "true" : "false") << " " << is_function<decltype(&A::Get)>::flag << std::endl;std::cout << (is_function<decltype(A::GetInstance)>::value ? "true" : "false") << " " << is_function<decltype(A::GetInstance)>::flag << std::endl;std::cout << (is_function<decltype(&B::fun)>::value ? "true" : "false") << " " << is_function<decltype(&B::fun)>::flag << std::endl;std::cout << (is_function<int(int)const>::value ? "true" : "false") << " " << is_function<int(int)const>::flag << std::endl;std::cout << (is_function<int(int) &>::value ? "true" : "false") << " " << is_function<int(int) &>::flag << std::endl;std::cout << (std::is_function<decltype(&A::Get)>::value ? "true" : "false") << std::endl;return 0;
}

需要注意几个问题：

is_function识别的是函数类型，对于函数需要通过decltype推断出其函数类型，如decltype(printf)
is_function可以识别类的静态成员函数，无法识别非静态成员函数
is_function不能处理所有函数类型，因为有些函数还包含const和volatile，到c++17之后，还包含noexcept操作符，如int(int) const
此外还应该处理函数的引用情况，关于函数的引用，解释如下（摘自c 成员函数声明()后加&或&&表示什么）：

C++中，成员函数声明后添加 & 或 && 表明这个成员函数是针对左值对象还是右值对象进行操作的。具体来说，在成员函数声明后加上 & 表示该成员函数只能被左值对象调用、而加上 && 表示该成员函数只能被右值对象调用。这种技术是C++11引入的，用于支持移动语义和更精细地控制对象的行为。

更多is_function的重载，如下（非全部）：

template <typename Ret, typename ...Args>
struct is_function<Ret(Args...) const> : std::true_type { constexpr static int flag = 3; };template <typename Ret, typename ...Args>
struct is_function<Ret(Args..., ...) const> : std::true_type { constexpr static int flag = 4; };template <typename Ret, typename ...Args>
struct is_function<Ret(Args...) volatile> : std::true_type { constexpr static int flag = 5; };template <typename Ret, typename ...Args>
struct is_function<Ret(Args..., ...) volatile> : std::true_type { constexpr static int flag = 6; };template <typename Ret, typename ...Args>
struct is_function<Ret(Args...) const volatile> : std::true_type { constexpr static int flag = 7; };template <typename Ret, typename ...Args>
struct is_function<Ret(Args..., ...) const volatile> : std::true_type { constexpr static int flag = 8; };template <typename Ret, typename ...Args>
struct is_function<Ret(Args...) &> : std::true_type { constexpr static int flag = 9; };template <typename Ret, typename ...Args>
struct is_function<Ret(Args..., ...) &> : std::true_type { constexpr static int flag = 10; };template <typename Ret, typename ...Args>
struct is_function<Ret(Args...) const &> : std::true_type { constexpr static int flag = 11; };template <typename Ret, typename ...Args>
struct is_function<Ret(Args..., ...) const &> : std::true_type { constexpr static int flag = 12; };template <typename Ret, typename ...Args>
struct is_function<Ret(Args...) volatile &> : std::true_type { constexpr static int flag = 13; };template <typename Ret, typename ...Args>
struct is_function<Ret(Args..., ...) volatile &> : std::true_type { constexpr static int flag = 14; };template <typename Ret, typename ...Args>
struct is_function<Ret(Args...) const volatile &> : std::true_type { constexpr static int flag = 15; };template <typename Ret, typename ...Args>
struct is_function<Ret(Args..., ...) const volatile &> : std::true_type { constexpr static int flag = 16; };

以上仅是基础实现，libc++，libstdc++，MS stl还有更为简单的实现，如下：

template<class T>
struct is_function : std::integral_constant<bool,!std::is_const<const T>::value && !std::is_reference<T>::value
> {};

判断class类型

原理：只有class类型才可以被用于指向成员的指针类型，即对于T Y::*一类的类型结构，Y只能是class类型，T可以选择任何类型。

#include <type_traits>
#include <iostream>template <typename T, typename = std::void_t<>>
struct is_class : std::false_type {};template <typename T>
struct is_class<T, std::void_t<int T::*>> : std::true_type {};struct s {};
class c {};
union u {};
enum e {};int main(int argc, char **argv) {std::cout << (is_class<s>::value ? "true" : "false") << std::endl;std::cout << (is_class<c>::value ? "true" : "false") << std::endl;std::cout << (is_class<u>::value ? "true" : "false") << std::endl;std::cout << (is_class<e>::value ? "true" : "false") << std::endl;auto f = []{};std::cout << (is_class<decltype(f)>::value ? "true" : "false") << std::endl;std::cout << (is_class<uint64_t>::value ? "true" : "false") << std::endl;std::cout << (is_class<int>::value ? "true" : "false") << std::endl;return 0;
}

需要注意两点以下两点：

c++语言指出，lambda 表达式的类型是“唯一的，未命名的，非枚举 class 类型”，使用is_class萃取lambda表达式，得到的结果也是true
int T::*表达式同样适用于 union类型