跟我学c++中级篇——STL中的Type Trait和Type Utility

一、萃取

在整个STL，萃取（Trait）怎么说都是不为过分的，在c++这种静态语言中，这也是勉强可以拿来和JAVA等语言说一说的类型操作技术了。通用或者共通类型，其实也是萃取应用的一个方面，就是把可以处理的不同的类型处理起来，或者说不能共同处理的数据类型提供一个判断并将结果返回给用户。
而在c++中把一些函数和相关的数据操作通过Wrapper的方式进行了封装，特别是存在于 中的std::function<>，把函数对象化，更方便于整个面向OOP的理解和应用。

二、Type Trait

这玩意儿其实就是数据类型的一个东西，萃取在前面讲过很多，这里就不再继续赘述，只讲一下它的具体应用：
1、类型的判断和处理

#include <iostream>
#include <type_traits>
 
class A {};
 
enum E : int {};
 
template <class T>
T f(T i)
{
    static_assert(std::is_integral<T>::value, "Integral required.");
    return i;
}
 
int main() 
{
    std::cout << std::boolalpha;
    std::cout << std::is_integral<A>::value << '\n';
    std::cout << std::is_integral_v<E> << '\n';
    std::cout << std::is_integral_v<float> << '\n';
    std::cout << std::is_integral_v<int> << '\n';
    std::cout << std::is_integral_v<const int> << '\n';
    std::cout << std::is_integral_v<bool> << '\n';
    std::cout << f(123) << '\n';
}

又比如：

template <typename T>
diff_int(T t,ture_type)
{
}
template <typename T>
diff_int(T t,false_type)
{
}
template <typename T>
void diff(T t)
{
  diff_int(t,std::is_integral<T>());
}

判断两种类型，通过类型的结果来调用不同的函数。更多的相关资料请查阅下面的网址：
https://en.cppreference.com/w/cpp/types

2、类型的修饰
其实这个就类似于为类型增加一些属性，比如增加一个引用或者const等。

add_const<T>
remove_const<T>
add_cv<T>
add_lvalue_reference<T>

看一个例子：

#include <iostream>
#include <type_traits>
 
struct foo
{
    void m() { std::cout << "Non-cv\n"; }
    void m() const { std::cout << "Const\n"; }
    void m() volatile { std::cout << "Volatile\n"; }
    void m() const volatile { std::cout << "Const-volatile\n"; }
};
 
int main()
{
    foo{}.m();
    std::add_const<foo>::type{}.m();
    std::add_volatile<foo>::type{}.m();
    std::add_cv<foo>::type{}.m();
}

还有不少，请查阅：
https://en.cppreference.com/w/cpp/types

三、打包器(reference wrapper和 function type wrapper)

这里最典型的当然是函数对象，这个在前面的也讲过，看一下应用：

#include <functional>
#include <iostream>
 
struct Foo {
    Foo(int num) : num_(num) {}
    void print_add(int i) const { std::cout << num_+i << '\n'; }
    int num_;
};
 
void print_num(int i)
{
    std::cout << i << '\n';
}
 
struct PrintNum {
    void operator()(int i) const
    {
        std::cout << i << '\n';
    }
};
 
int main()
{
    // store a free function
    std::function<void(int)> f_display = print_num;
    f_display(-9);
 
    // store a lambda
    std::function<void()> f_display_42 = []() { print_num(42); };
    f_display_42();
 
    // store the result of a call to std::bind
    std::function<void()> f_display_31337 = std::bind(print_num, 31337);
    f_display_31337();
 
    // store a call to a member function
    std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;
    const Foo foo(314159);
    f_add_display(foo, 1);
    f_add_display(314159, 1);
 
    // store a call to a data member accessor
    std::function<int(Foo const&)> f_num = &Foo::num_;
    std::cout << "num_: " << f_num(foo) << '\n';
 
    // store a call to a member function and object
    using std::placeholders::_1;
    std::function<void(int)> f_add_display2 = std::bind( &Foo::print_add, foo, _1 );
    f_add_display2(2);
 
    // store a call to a member function and object ptr
    std::function<void(int)> f_add_display3 = std::bind( &Foo::print_add, &foo, _1 );
    f_add_display3(3);
 
    // store a call to a function object
    std::function<void(int)> f_display_obj = PrintNum();
    f_display_obj(18);
 
    auto factorial = [](int n) {
        // store a lambda object to emulate "recursive lambda"; aware of extra overhead
        std::function<int(int)> fac = [&](int n){ return (n < 2) ? 1 : n*fac(n-1); };
        // note that "auto fac = [&](int n){...};" does not work in recursive calls
        return fac(n);
    };
    for (int i{5}; i != 8; ++i) { std::cout << i << "! = " << factorial(i) << ";  "; }
}

代码出自：
https://en.cppreference.com/w/cpp/utility/functional/function
更多的可以查阅相关网址的内容。

四、总结

Type Utility(Utility to simplify expressions used in unevaluated operands)，也即是在c++11中提供了很多类型实用函数。或者说Type Trait在c++11上把一些常用的封装好了。这样用起来就方便了许多，比如decltype,sizeof等等。
STL中有很多知识点是互为基础和延展使用的，在这一点上，大家一定要注意，特别是学习c++11以上版本上，版本的快速迭代，导致了一些小的细节的变化，特别是增加的一些小功能，往往起到了一些画龙点睛的作用。虽然可能应用只是在局部的一个小小的范围内，但可能让你感到有一种特别的感觉（可能是舒适也可能是不舒适）。这个需要不断的跟进和学习。
努力吧，归来的少年！