STL源码剖析(侯捷)笔记——算法

1、算法工作原理

算法是function template,其他stl部件是类模板

算法在实现功能时，因为不知道容器是什么，所以全部信息都要靠迭代器来提供。

template<typename Iterator, typename Cmp>
Algorithm(Iterator iter1, Iterator iter2, Cmp comp) {}
其中的cmp是一个仿函数

2、iterator的分类,iterator_category

2.1 几种迭代器

array: random_access_iterator_tag，随机访问迭代器
vector:同上
deque：同上
list: bidirectional_iterator_tag:双向迭代器
forward_List:forward_iterator_tag:单向迭代器
set\multiset\map\multimap:bidirectional_iterator_tag;
unordered set\...:取决于拉链是双向链表还是单项链表

2.2 测试各容器内部的迭代器类型

#include <unordered_set>
#include <typeinfo>
#include <bits/stdc++.h>
using namespace std;

// 函数重载
void _display(random_access_iterator_tag iter) {
	cout << "random_access_iterator_tag" << endl;
}

void _display(bidirectional_iterator_tag iter) {
	cout << "bidirectional_iterator_tag" << endl;
}

void _display(input_iterator_tag iter) {
	cout << "input_iterator_tag" << endl;
}

void _display(output_iterator_tag iter) {
	cout << "output_iterator_tag" << endl;
}

void _display(forward_iterator_tag iter) {
	cout << "forward_Iterator_tag" << endl;
}

template<typename I>
void display_category(I iter) {
	typename iterator_traits<I>::iterator_category cagy;
	_display(cagy);
}

int main() {
	cout << "test iterator\n";
	display_category(array<int, 10>::iterator());
	display_category(vector<int>::iterator());
	display_category(unordered_set<int>::iterator());
	display_category(istream_iterator<int>());
	display_category(ostream_iterator<int>(cout, ""));
}
istream和ostream比较特殊

2.3 验证类型：#include

#include <typeinfo>

cout << typeid(int).name() << endl;  // 输出 int 

2.4 istream_iterator和ostream_iterator

3、算法

3.1 几个例子

template<class InputIterator>
inline iterator_traits<InputIterator>::difference_type
_distance(InputIterator first, InputIterator last, input_iterator_tag) {

//input_iterator_tag为最底层的父类
	iterator_traits<input_iterator_tag>::difference_type n = 0;
	while (first != last) {
		++first;
		++n;
	}
	return n;
}

template<class RandomAccessIterator>
inline iterator_traits<RandomAccessIterator>::difference_type
_distance(RandomAccessIterator first, RandomAccessIterator last, random_access_iterator_tag) {
	return last - first;
}

主函数：它底层根据传进来的迭代器类型，有编译器选择调用上面两个重载函数的其中一个
template<class InputIterator>
inline iterator_traits<InputIterator>::difference_type // 萃取迭代器之间的距离类型
distance(InputIterator first, InputIterator last) {
	typedef typename iterator_traits<InputIterator>::iterator_category category; // 萃取类型
	return _distance(first, last, category());// typename+()=创建了一个对象
}

在distance函数中，通过萃取机萃取传入的迭代器的iterator_category,传入_distance中，根据第三个参数选择上面某个重载函数进行调用。效率显然，randomaccessIterator更快。

注：为什么只重载了2个版本的迭代器，forward_iterator,bindirectional_iterator为社么没有重载？

答：因为单向和双向都是继承了input_iterator，对于求迭代器之间的距离来说，他们是链表，只能一步一步加上去，和input_iterator实现是一样的，所以无需单独拿出来重载。

例2：

上图为实现前进n个距离的算法。其中advance()中在萃取迭代器类型时，创建了一个新的函数并返回category()，和distance()中实现效果一样的，因此萃取类型时也可用下面的语句：

typedef typename iterator_traits<InputIterator>::iterator_category category;
	_advance(i,n,category());

例3：

例三中的copy方法，通过一层一层的进行分类，找到一种最优的方法完成数据的拷贝。其中包含了一个type_traits，后面的笔记中会讲到。

3.2 算法源码中对iterator_category的暗示

如上图中所示，算法没办法强制接受某种类型，所以在源代码中会给予暗示。

如sort()算法，使用的类模板名称写成了RandomAccessIterator，虽然这只是个名字，可以叫做任何其他的名字，但是这样写就可以告诉开发者，sort函数只能对随机访问迭代器生效，传入其他的迭代器类型会报错。

3.3 STL标准库中算法模板

3.3.1 accumulate

template<class InputIterator, class T>
T accumulate(InputIterator first, InputIterator last, T init) {
	for (; first != last; ++first) {
		init += *first;
	}
	return init;
}

template<class InputIterator, class T, class BinaryOperation>
T accumulate(InputIterator first, InputIterator last, T init, BinaryOperation binary_op) {
	for (; first != last; ++first) {
		init = binary_op(init, *first);
	}
}

accumulate有一个重载版本，即可以选择一个包含两个参数的函数或者重载了()的类对象作为第三参数，如：

// 函数
int my_func(int x, int y) {return x+y;}
// 重载()的类对象
struct my_struct{
	int operator()(int x, int y){return x+2*y;}
} my_obj;

使用如下：
vector<int> vec{1,2,3};
accumulate(vec.begin(), vec.end(), 0, my_func); //output:6
accumulate(vec.begin(), vec.end(), 0, my_obj); //output:12

3.3.2 for_each

template<class InputIterator, class Function>
Function for_each(InputIterator first, InputIterator last,Function f) {
	for (; first != last; ++first)
		f(*first);
	return f;
}

自定义函数或类对象:
void my_func(int x) cout << x << endl;
struct my_class{
	void operator()(int x) cout << x << endl;
}

使用同accumulate

3.3.3 replace replace_if replace_copy

// 函数模板 replace
template<class ForwardIterator, class T>
void replace(ForwardIterator first, ForwardIterator last, const T& old_value,const T& new_value) {
	for (; first != last; ++first) {
		if(*first == old_value) *first = new_value;
	}
}

// 函数模板replace_if， predicate为一个判断函数，该函数为true时对迭代器所指元素进行替代
template<class ForwardIterator, class Predicate, class T> // predicate为判断函数,返回t or f
void replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value) {
	for (; first != last; ++first) {
		if (pred(*first)) *first = new_value;
	}
}

// 函数模板replace_copy，将迭代器所指向的数组等复制到另一块区域，并将等于旧值的元素替换成新的值
template<class ForwardIterator, class OutputIterator, class T>
OutputIterator replace_copy(ForwardIterator first, ForwardIterator last, OutputIterator result, const T& old_value, const T& new_value) {
	for (; first != last; ++first, ++result) {
		*result = *first==old_value?new_value:old_value;
	}
	return result;
}

3.3.4 count、count_if

// 模板函数count
template<class InputIterator, class T>
typename iterator_traits<InputIterator>::difference_type 
count(InputIterator first, InputIterator last, const T& value) {
	typename iterator_traits<InputIterator>::difference_type n = 0;
	for (; first != last; ++first) // 从头到尾一个一个搜索
		if (*first == value) ++n;
	return n;
}

// count_if
template<class InputIterator, class Predicate>
typename iterator_traits<InputIterator>::difference_type
count_if(Itertator first, Iterator last, Predicate pred){
	typename iterator_traits<InputIterator>::difference_type n = 0;
	for (; first != last; ++first) {
		if (pred(*first)) ++n;
	}
	return n;
}

不带成员函数count()的容器:array,vector,list,deque,forward_list
带成员函数Count()的容器:set,map,multiset,multimap,unordered_......

3.3.5 find,find_if

template <class InputIterator, class T>
InputIterator find(InputIterator first, InputIterator last, const T& value) {
	for (; first != last && *first != value; );
		++first;
	return first;
}

template <class InputIterator, class Predicate>
InputIterator find_if(InputIterator first, InputIterator last, Predicate pred) {
	for (; first != last && !pred(*first); )	
		++first;
	return first;
}

不带成员函数count()的容器:array,vector,list,deque,forward_list
带成员函数Count()的容器:set,map,multiset,multimap,unordered_......	

3.3.6 sort

带成员函数sort()的容器: list， forward_list

不带成员函数sort()的容器：其他所有容器。

[文档及视频资源github地址(非本人整理)：https://github.com/ZachL1/Bilibili-plus]