【笔记】C++标准库: 体系结构与内核分析(下)

// 先让模板函数自己推导迭代器类型
template <typename I>
void do_something(I iter){
    // 由于迭代器继承了某个迭代器类型, 因此萃取器可以询问迭代器类型
    typename iterator_traits<I>::iterator_category cagy;
    // 然后这个迭代器类型可以用来调用重载函数
    _do_sth(cagy);
}

...
// 通过给函数加入"特化"了迭代器类型的匿名参数, 程序就可以利用重载进行跳转
// 且由于迭代器类型是继承关系的类, 失配的时候还能借助上转型进行泛化的匹配
void _do_sth(input_iterator_tag){}
void _do_sth(random_access_iterator_tag){}
...

// 使用模板函数作为入口是因为只有模板函数能进行模板实参推导, 核心依然是函数里的模板类
template <class Operation, class T>
inline binder2nd<Operation> bind2nd(const Operation& op, const T& x){
    // 询问仿函数其参数的类型, 这需要仿函数继承可适配接口
    // 这里额外标注typename是为了告知编译器此时不用检查Operation是否有这个成员
    typedef typename Operation::second_argument_type arg2_type;
    // 利用推导出来的类型进行模板类构造, binder2nd才是真正发生适配的地方
    // 这里用arg2_type(x)来将实际传入的参数转为适合仿函数的类型, 也算一种编译时类型检查
    return binder2nd<Operation>(op, arg2_type(x));
}

// 实际进行适配的模板类, 目的是让自己表现得像是绑定了第二实参后的仿函数自己
template <class Operation>
// 这里继承仿函数可适配接口unary_function是为了让适配后的自己又成为一个仿函数
// 从而可以给其它适配器进行嵌套适配, 这里选择了单个参数的unary_function
class binder2nd: public unary_function<
    typename Operation::first_argument_type, 
    typename Operation::result_type>
{
protected:
    // 适配器接收到的仿函数的本体
    Operation op;
    // 适配器接收到的要输入仿函数的额外参数
    typename Operation::second_argument_type value;
public:
    // 在构造的时候进行仿函数和参数的初始化
    binder2nd(const Operation& x, 
              const typename Operation::second_argument_type& y):
              op(x), value(y){}
    // 重载调用运算符让自己也变为一个仿函数, 返回值的类型与原先相同
    typename Operation::result_type 
        // 此时只需要接受一个实参了, 实参类型与之前相同
        operator()(const typename Operation::first_argument_type& x) const{
        // 将准备好的参数和当前接收到的参数放入准备好的仿函数中包装调用并返回
        return op(x, value);
    }
};

// 首先是模板函数的入口, 这一系列函数都是模板重载的范例
// 这里用到了可变模板参数, 通过三个点(...)的标识, 可以传入任意数量的参数
template <typename... Types>
// 最泛化的版本, 接收所有参数作为入口
inline size_t hash_val(const Types&... args){
    // 通过传引用来修改返回值seed
    size_t seed = 0;
    // 由于是模板函数, 所以根据实参推导转到下面的函数
    hash_val(seed, args...);
    return seed;
}

// 接受seed和可变数量的参数, 这是递归的主要部分
template <typename T, typename... Types>
// 通常传到这里的时候seed之后的参数数量都是不定的, 由于可变模板参数的设计
// 这里编译器会自动进行切分, 将可变参数的第一个区分出来, 然后剩余的继续传递
// 这种写法在C++11之后的STL中出现得很多, 一定要注意
inline size_t hash_val(size_t& seed, const T& val, const Types&... args){
    // 此时的val就是当前列表里的第一个参数, 用来刷新现在的hashcode
    hash_combine(seed, val);
    // 更新后的seed继续传递
    // 这里不再传递val了, 因此参数列表就减少了一个项, 继续递归下去直到只剩一个参数
    hash_val(seed, args...);
}

// 至此为止是模板递归的最后一层, 只剩下一个参数时进入
template <typename T>
inline size_t hash_val(size_t& seed, const T& val){
    // 仅仅是刷新最后的seed然后开始返回
    hash_combine(seed, val);
}

// 这里是计算hashcode的函数, 将其理解为黑盒就行
#include <functional>
template <typename T>
// 只接受两个参数, 分别是当前hashcode和新出现的需要附加到hashcode中的参数
inline void hash_combine(size_t& seed, const T& val){
    // 主要是调用了std的hash仿函数来对基本类型进行散列
    // 其它部分就是一些打乱操作, 没什么特别的原理, 下面的魔数是黄金分割数
    seed^=std::hash<T>()(val) + 0x9e3779b9 + ((seed<<6) + (seed>>2));
}

// 追加在std内方便处理
namespace std{
    // 给自己的类型偏特化一份
    template<>
    struct hash<MyClass>{
        // 关键是重载调用运算符, 因为hash属于仿函数
        size_t operator()(const MyClass& inp) const noexcept{
            // 自己想办法返回自定义的hashcode即可
            return inp._do_something();
        }
    }
}

// 空构造
tuple<string, int, float> t0;
// 带元素构造
tuple<string, int, float> t("something", 42, 42.0);
// 用辅助模板函数推断构造
t = make_tuple("something", 42, 42.0);
// 读取tuple的元素, 注意不要越界
string s = get<0>(t);
int i = get<1>(t);
float f = get<2>(t);
// 对某一项赋值, 注意类型问题
get<1>(t) = get<2>(t);
// tuple间的比较, 整体赋值之类的自然也是可以的
bool b = t0 < t;
t0 = t;
// 用tie()函数将tuple赋值给离散的元素
tie(s, i, f) = t;
// 询问tuple的成员数量
typedef tuple<string, int, float> t_type;
size_t num = tuple_size<t_type>::value;
// 询问tuple某个成员的类型
typedef tuple_element<0, t_type>::type v_type;

// 最泛化版本的tuple
template<typename... Values> class tuple;
// 最特化版本的tuple, 作为递归继承的最后一层存在
template<> class tuple<> {};
// 递归继承的主要部分, 充分利用了可变模板参数列表会被自动切分的特性
template<typename Head, typename... Tail>
// 参数更多的tuple递归继承自参数少的tuple
class tuple<Head, Tail...>: private tuple<Tail...>{
    // 改个名字
    typedef tuple<Tail...> inherited;
public:
    tuple(){}
    // 构造的时候初始化一个属于当前层次的元素head, 其它部分都用来初始化父类
    tuple(Head vhead, Tail... vtail): m_head(vhead), inherited(vtail...){}
    // 返回当前层次的元素
    typename Head::type head(){
        return m_head;
    }
    // 借助上转型变为自己的父类, 由于继承关系在内存中呈线性排列, 因此放心转型
    inherited& tail(){
        // 返回父类的指针从而可以继续递归
        return *this;
    }
protected:
    // 每一层继承有一个这样的元素, 是这一层真正保存的元素
    Head m_head;
}

string s1(s2);  // 普通拷贝构造
string s1(std::move(s2));   // 调用搬移构造