本文将6篇文章中出现的代码整合在一起,主要参考了HP的STL源码。通过这些代码,不仅可以看到这些C++技术在STL中的运用,同时也能大致了解STL的架构组织及实现方法。首先给出一个测试用例,所有代码都是自定义的,未用到STL。读者可以建立一个C++工程,把这些代码加进去,就可以运行起来。方便之处在于,读者可以修改这些代码,实现一些自己的功能,以加深对于STL的理解。
STL真正实现中,其实也就是对下述代码的扩展,定义更多的容器、算法、函数对象、迭代器等,至于具体实现的方法,仅仅是数据结构、算法自身上的差异,整体的实现步骤或者说是架构都是一样的。比如如果要实现deque,就需要定义deque的迭代器,deque的数据结构。又比如要实现排序算法,它与容器没有关系,它的形参是迭代器。因此实现起来根本不用考虑具体的容器。当然有些容器的排序算法需要特别实现,比如List的排序算法就是单独实现的。再比如要实现新的函数对象,没有问题,只需继承最基本的两个类,然后实现自定义的功能。
当然,本文没有介绍STL的另一个重要组成部分,那就是内存的分配机制。感兴趣的读者可以看一下《STL源码剖析》这本书,或者找份源码看一下。
- #include "List.h" //自定义的链表
- #include "Algorithm.h" //自定义的算法
- #include "Functional.h" //自定义的函数对象
- #include <iostream>
- using namespace std;
- //测试程序 VS2008下测试通过
- int main()
- {
- List<int> l; //自定义的链表,STL链表的部分功能
- l.push_back(1); //链表功能测试
- l.push_back(2);
- //测试 萃取迭代器的类型功能
- MyAdvance(l.begin(), 1); //输出Random_access_iterator_tag
- //测试 萃取迭代器所指的数据类型
- Iterator_traits<int *>::value_type x = 5; //特化
- Iterator_traits<const int*>::value_type y = 6; //特化
- Iterator_traits<List<int>::iterator>::value_type z = 7; //list 容器
- cout<<x<<' '<<y<<' '<<z<<endl; //输出5 6 7
- //测试算法
- cout<<"before Iter_swap : "<<*(l.begin())<<' '<<*(++l.begin())<<endl; //输出1 2
- Iter_swap(l.begin(),++l.begin()); //交换两个迭代器的元素
- cout<<"after Iter_swap : "<<*(l.begin())<<' '<<*(++l.begin())<<endl; //输出2 1
- l.push_front(3);
- l.push_front(4);
- l.push_front(5);
- l.push_front(6);
- //测试函数对象
- //链表中的元素为 6 5 4 3 1 2
- int count1 = Count_if(l.begin(), l.end(), bind2nd(less_equal<int>(), 10)); //求容器中小于等于10的元素个数
- int count2 = Count_if(l.begin(), l.end(), not1(bind2nd(less_equal<int>(), 10))); //求容器中不小于等于10的元素个数,正好是上面结果的取反
- cout<<count1<<' '<<count2<<endl; //输出6 0
- int count3 = 0, count4 = 0;
- Count_if(l.begin(), l.end(), bind2nd(greater_equal<int>(), 3), count3); //求容器中大于等于3的元素个数
- Count_if(l.begin(), l.end(), not1(bind2nd(greater_equal<int>(), 3)), count4); //求容器中小于3的元素个数
- cout<<count3<<' '<<count4<<endl; //输出4 2
- l.clear();
- return 0;
- }
#include "List.h" //自定义的链表
#include "Algorithm.h" //自定义的算法
#include "Functional.h" //自定义的函数对象
#include <iostream>
using namespace std;
//测试程序 VS2008下测试通过
int main()
{
List<int> l; //自定义的链表,STL链表的部分功能
l.push_back(1); //链表功能测试
l.push_back(2);
//测试 萃取迭代器的类型功能
MyAdvance(l.begin(), 1); //输出Random_access_iterator_tag
//测试 萃取迭代器所指的数据类型
Iterator_traits<int *>::value_type x = 5; //特化
Iterator_traits<const int*>::value_type y = 6; //特化
Iterator_traits<List<int>::iterator>::value_type z = 7; //list 容器
cout<<x<<' '<<y<<' '<<z<<endl; //输出5 6 7
//测试算法
cout<<"before Iter_swap : "<<*(l.begin())<<' '<<*(++l.begin())<<endl; //输出1 2
Iter_swap(l.begin(),++l.begin()); //交换两个迭代器的元素
cout<<"after Iter_swap : "<<*(l.begin())<<' '<<*(++l.begin())<<endl; //输出2 1
l.push_front(3);
l.push_front(4);
l.push_front(5);
l.push_front(6);
//测试函数对象
//链表中的元素为 6 5 4 3 1 2
int count1 = Count_if(l.begin(), l.end(), bind2nd(less_equal<int>(), 10)); //求容器中小于等于10的元素个数
int count2 = Count_if(l.begin(), l.end(), not1(bind2nd(less_equal<int>(), 10))); //求容器中不小于等于10的元素个数,正好是上面结果的取反
cout<<count1<<' '<<count2<<endl; //输出6 0
int count3 = 0, count4 = 0;
Count_if(l.begin(), l.end(), bind2nd(greater_equal<int>(), 3), count3); //求容器中大于等于3的元素个数
Count_if(l.begin(), l.end(), not1(bind2nd(greater_equal<int>(), 3)), count4); //求容器中小于3的元素个数
cout<<count3<<' '<<count4<<endl; //输出4 2
l.clear();
return 0;
}
首先给出迭代器萃取剂的定义,代码如下。可以看到内嵌型别技术,模板特化技术,重载函数的精妙运用。
- //Iterator_traits.h
- #pragma once
- //迭代器分类,大写已便于标准库区分
- struct Input_iterator_tag {};
- struct Output_iterator_tag {};
- struct Forward_iterator_tag : public Input_iterator_tag {};
- struct Bidirectional_iterator_tag : public Forward_iterator_tag {};
- struct Random_access_iterator_tag : public Bidirectional_iterator_tag {};
- //萃取剂
- template<class I>
- struct Iterator_traits{
- typedef typename I::value_type value_type;
- typedef typename I::iterator_category iterator_category; //迭代器的类型
- typedef typename I::difference_type difference_type;
- typedef typename I::pointer pointer;
- typedef typename I::reference reference;
- };
- //特化 原生指针
- template<class T>
- struct Iterator_traits<T*>{
- typedef T value_type;
- typedef Random_access_iterator_tag iterator_category;
- typedef ptrdiff_t difference_type;
- typedef T* pointer;
- typedef T& reference;
- };
- //特化 原生常指针
- template<class T>
- struct Iterator_traits<const T*>{
- typedef T value_type;
- typedef Random_access_iterator_tag iterator_category;
- typedef ptrdiff_t difference_type;
- typedef const T* pointer;
- typedef const T& reference;
- };
- //萃取剂
- #define VALUE_TYPE(I) Iterator_traits<I>::value_type()
- #define ITERATOR_CATEGORY(I) Iterator_traits<I>::iterator_category()
- #define DIFFERENCE_TYPE(I) Iterator_traits<I>::difference_type()
- #define POINTER(I) Iterator_traits<I>::pointer()
- #define REFERENCE(I) Iterator_traits<I>::reference()
- //自定义的advance函数,与STL差不多
- template <class InputIterator, class Distance>
- inline void MyAdvance(InputIterator &i, Distance n)
- {
- _MyAdvance(i, n, ITERATOR_CATEGORY(InputIterator)); //萃取迭代器的类型
- }
- template <class InputIterator, class Distance>
- inline void _MyAdvance(InputIterator& i, Distance n, Input_iterator_tag)
- {
- while (n--) ++i;
- cout<<"InputIterator"<<endl;
- }
- template <class BidirectionalIterator, class Distance>
- inline void _MyAdvance(BidirectionalIterator& i, Distance n, Bidirectional_iterator_tag)
- {
- if (n >= 0)
- while (n--) ++i;
- else
- while (n++) --i;
- cout<<"BidirectionalIterator"<<endl;
- }
- template <class RandomAccessIterator, class Distance>
- inline void _MyAdvance(RandomAccessIterator& i, Distance n, Random_access_iterator_tag)
- {
- i += n;
- cout<<"RandomAccessIterator"<<endl;
- }
//Iterator_traits.h
#pragma once
//迭代器分类,大写已便于标准库区分
struct Input_iterator_tag {};
struct Output_iterator_tag {};
struct Forward_iterator_tag : public Input_iterator_tag {};
struct Bidirectional_iterator_tag : public Forward_iterator_tag {};
struct Random_access_iterator_tag : public Bidirectional_iterator_tag {};
//萃取剂
template<class I>
struct Iterator_traits{
typedef typename I::value_type value_type;
typedef typename I::iterator_category iterator_category; //迭代器的类型
typedef typename I::difference_type difference_type;
typedef typename I::pointer pointer;
typedef typename I::reference reference;
};
//特化 原生指针
template<class T>
struct Iterator_traits<T*>{
typedef T value_type;
typedef Random_access_iterator_tag iterator_category;
typedef ptrdiff_t difference_type;
typedef T* pointer;
typedef T& reference;
};
//特化 原生常指针
template<class T>
struct Iterator_traits<const T*>{
typedef T value_type;
typedef Random_access_iterator_tag iterator_category;
typedef ptrdiff_t difference_type;
typedef const T* pointer;
typedef const T& reference;
};
//萃取剂
#define VALUE_TYPE(I) Iterator_traits<I>::value_type()
#define ITERATOR_CATEGORY(I) Iterator_traits<I>::iterator_category()
#define DIFFERENCE_TYPE(I) Iterator_traits<I>::difference_type()
#define POINTER(I) Iterator_traits<I>::pointer()
#define REFERENCE(I) Iterator_traits<I>::reference()
//自定义的advance函数,与STL差不多
template <class InputIterator, class Distance>
inline void MyAdvance(InputIterator &i, Distance n)
{
_MyAdvance(i, n, ITERATOR_CATEGORY(InputIterator)); //萃取迭代器的类型
}
template <class InputIterator, class Distance>
inline void _MyAdvance(InputIterator& i, Distance n, Input_iterator_tag)
{
while (n--) ++i;
cout<<"InputIterator"<<endl;
}
template <class BidirectionalIterator, class Distance>
inline void _MyAdvance(BidirectionalIterator& i, Distance n, Bidirectional_iterator_tag)
{
if (n >= 0)
while (n--) ++i;
else
while (n++) --i;
cout<<"BidirectionalIterator"<<endl;
}
template <class RandomAccessIterator, class Distance>
inline void _MyAdvance(RandomAccessIterator& i, Distance n, Random_access_iterator_tag)
{
i += n;
cout<<"RandomAccessIterator"<<endl;
}
再给出一个容器的定义,这里用的List,实现了STL的部分功能,同时还出了相应的迭代器的实现。可以看到大量的重载操作符的实现。
- //List_iterator.h
- #pragma once
- #include "Iterator_traits.h"
- //结点定义,双向链表
- template <class T>
- struct List_node {
- List_node* next;
- List_node* prev;
- T data;
- };
- //链表的迭代器
- template<class T, class Ref, class Ptr>
- class List_iterator
- {
- public:
- List_node<T> *node;
- void Incr() { node = node->next; }
- void Decr() { node = node->prev; }
- public:
- typedef T value_type;
- typedef Ptr pointer;
- typedef Ref reference;
- typedef size_t size_type;
- typedef ptrdiff_t difference_type;
- typedef Bidirectional_iterator_tag iterator_category; //迭代器的类型是双向的
- typedef List_iterator<T, T&, T*> iterator; //迭代器
- typedef List_iterator<T, const T&, const T*> const_iterator;
- typedef List_iterator<T, Ref, Ptr> self;
- List_iterator(List_node<T>* x): node(x) {} //接受链表结点的构造函数,很管用
- List_iterator() {}
- reference operator*() const { return node->data; } //解引用重载
- pointer operator->() const { return &(operator*()); } //箭头重载
- self& operator++() { this->Incr(); return *this; } //前增重载
- self operator++(int) { self tmp = *this; this->Incr(); return tmp; } //后增重载
- self& operator--() { this->Decr(); return *this; } //前减重载
- self operator--(int) { self tmp = *this; this->Decr(); return tmp; } //后减重载
- bool operator==(const List_iterator& x) const { return node == x.node; } //相等重载
- bool operator!=(const List_iterator& x) const { return node != x.node; } //不相等重载
- };
//List_iterator.h
#pragma once
#include "Iterator_traits.h"
//结点定义,双向链表
template <class T>
struct List_node {
List_node* next;
List_node* prev;
T data;
};
//链表的迭代器
template<class T, class Ref, class Ptr>
class List_iterator
{
public:
List_node<T> *node;
void Incr() { node = node->next; }
void Decr() { node = node->prev; }
public:
typedef T value_type;
typedef Ptr pointer;
typedef Ref reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef Bidirectional_iterator_tag iterator_category; //迭代器的类型是双向的
typedef List_iterator<T, T&, T*> iterator; //迭代器
typedef List_iterator<T, const T&, const T*> const_iterator;
typedef List_iterator<T, Ref, Ptr> self;
List_iterator(List_node<T>* x): node(x) {} //接受链表结点的构造函数,很管用
List_iterator() {}
reference operator*() const { return node->data; } //解引用重载
pointer operator->() const { return &(operator*()); } //箭头重载
self& operator++() { this->Incr(); return *this; } //前增重载
self operator++(int) { self tmp = *this; this->Incr(); return tmp; } //后增重载
self& operator--() { this->Decr(); return *this; } //前减重载
self operator--(int) { self tmp = *this; this->Decr(); return tmp; } //后减重载
bool operator==(const List_iterator& x) const { return node == x.node; } //相等重载
bool operator!=(const List_iterator& x) const { return node != x.node; } //不相等重载
};
- //List.h
- #pragma once
- #include "List_iterator.h"
- //资源分配器
- class MyAlloc
- {
- };
- //链表定义
- template <class T, class Alloc = MyAlloc >
- class List {
- public:
- typedef List_node<T> list_node; //结点类型
- typedef list_node* list_type; //结点指针
- typedef T value_type;
- typedef value_type* pointer;
- typedef const value_type* const_pointer;
- typedef value_type& reference;
- typedef const value_type& const_reference;
- typedef size_t size_type;
- typedef ptrdiff_t difference_type;
- typedef List_iterator<T, T&, T*> iterator; //迭代器
- typedef List_iterator<T, const T&, const T*> const_iterator;
- public:
- List() { node = get_node(); node->next = node; node->prev = node; } //构造哨兵结点
- ~List() { clear(); }
- //返回类型要求是iterator,而实际返回的是结点指针,为什么可以呢?关键在于List_iterator有一个接受结点指针的构造函数
- iterator begin() { return node->next; }
- const_iterator begin() const { return node->next; }
- iterator end() { return node; }
- const_iterator end() const { return node; }
- bool empty() const { return node->next == node; }
- reference front() { return *begin(); }
- const_reference front() const { return *begin(); }
- reference back() { return *(--end()); }
- const_reference back() const { return *(--end()); }
- void push_front(const T& x) { insert(begin(), x); }
- void push_back(const T& x) { insert(end(), x); }
- void pop_front() { erase(begin()); }
- void pop_back() { iterator tmp = end(); erase(--tmp); }
- //插入结点
- void insert(iterator pos, const T &x) {
- list_type tmp = get_node();
- tmp->data = x;
- tmp->next = pos.node;
- tmp->prev = pos.node->prev;
- (pos.node->prev)->next = tmp;
- pos.node->prev = tmp;
- }
- //删除结点
- iterator erase(iterator pos) {
- list_type next_node = pos.node->next;
- list_type prev_node = pos.node->prev;
- prev_node->next = next_node;
- next_node->prev = prev_node;
- put_node(pos.node);
- return next_node;
- }
- //清除所有结点
- void clear() {
- list_type cur = node->next;
- while(cur != node)
- {
- list_type tmp = cur;
- cur = cur->next;
- put_node(tmp);
- }
- node->next = node;
- node->prev = node;
- }
- private:
- list_type node;
- list_type get_node() { return new list_node; } //分配空间
- void put_node(list_type p) { delete p; p = NULL; } //释放空间
- };
//List.h
#pragma once
#include "List_iterator.h"
//资源分配器
class MyAlloc
{
};
//链表定义
template <class T, class Alloc = MyAlloc >
class List {
public:
typedef List_node<T> list_node; //结点类型
typedef list_node* list_type; //结点指针
typedef T value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef List_iterator<T, T&, T*> iterator; //迭代器
typedef List_iterator<T, const T&, const T*> const_iterator;
public:
List() { node = get_node(); node->next = node; node->prev = node; } //构造哨兵结点
~List() { clear(); }
//返回类型要求是iterator,而实际返回的是结点指针,为什么可以呢?关键在于List_iterator有一个接受结点指针的构造函数
iterator begin() { return node->next; }
const_iterator begin() const { return node->next; }
iterator end() { return node; }
const_iterator end() const { return node; }
bool empty() const { return node->next == node; }
reference front() { return *begin(); }
const_reference front() const { return *begin(); }
reference back() { return *(--end()); }
const_reference back() const { return *(--end()); }
void push_front(const T& x) { insert(begin(), x); }
void push_back(const T& x) { insert(end(), x); }
void pop_front() { erase(begin()); }
void pop_back() { iterator tmp = end(); erase(--tmp); }
//插入结点
void insert(iterator pos, const T &x) {
list_type tmp = get_node();
tmp->data = x;
tmp->next = pos.node;
tmp->prev = pos.node->prev;
(pos.node->prev)->next = tmp;
pos.node->prev = tmp;
}
//删除结点
iterator erase(iterator pos) {
list_type next_node = pos.node->next;
list_type prev_node = pos.node->prev;
prev_node->next = next_node;
next_node->prev = prev_node;
put_node(pos.node);
return next_node;
}
//清除所有结点
void clear() {
list_type cur = node->next;
while(cur != node)
{
list_type tmp = cur;
cur = cur->next;
put_node(tmp);
}
node->next = node;
node->prev = node;
}
private:
list_type node;
list_type get_node() { return new list_node; } //分配空间
void put_node(list_type p) { delete p; p = NULL; } //释放空间
};
再来给出函数对象的定义,可以看到绑定器,取反器的具体实现。
- //Functional.h
- #pragma once
- //用来定义一元操作的参数类别和返回值类别
- template <class Arg, class Result>
- struct unary_function {
- typedef Arg argument_type; //内嵌型别技术
- typedef Result result_type;
- };
- //用来定义二元操作的参数类别和返回值类别
- template <class Arg1, class Arg2, class Result>
- struct binary_function {
- typedef Arg1 first_argument_type;
- typedef Arg2 second_argument_type;
- typedef Result result_type;
- };
- //一元操作,就两个
- template <class T>
- struct negate : public unary_function<T, T> {
- T operator()(const T& x) const { return -x; }
- };
- template <class T>
- struct logical_not : public unary_function<T,bool> {
- bool operator()(const T& x) const { return !x; }
- };
- //加减乘除取模
- template <class T>
- struct plus : public binary_function<T, T, T> {
- T operator()(const T& x, const T& y) const { return x + y; }
- };
- template <class T>
- struct minus : public binary_function<T, T, T> {
- T operator()(const T& x, const T& y) const { return x - y; }
- };
- template <class T>
- struct multiplies : public binary_function<T, T , T> {
- T operator()(const T& x, const T& y) const { return x * y; }
- };
- template <class T>
- struct divides : public binary_function<T ,T, T> {
- T operator()(const T& x, const T& y) const { return x / y; }
- };
- template <class T>
- struct modulus : public binary_function<T, T, T> {
- T operator()(const T& x, const T& y) const { return x % y; }
- };
- //关系运算
- template <class T>
- struct equal_to : public binary_function<T, T, bool> {
- bool operator()(const T& x, const T& y) const { return x == y; }
- };
- template <class T>
- struct not_equal_to : public binary_function<T, T,bool> {
- bool operator()(const T& x, const T& y) const { return x != y; }
- };
- template <class T>
- struct greater : public binary_function<T, T, bool> {
- bool operator()(const T& x, const T& y) const { return x > y; }
- };
- template <class T>
- struct less : public binary_function<T, T, bool> {
- bool operator()(const T& x, const T& y) const { return x < y; }
- };
- template <class T>
- struct greater_equal : public binary_function<T, T, bool> {
- bool operator()(const T& x, const T& y) const { return x >= y; }
- };
- template <class T>
- struct less_equal : public binary_function<T, T, bool> {
- bool operator()(const T& x, const T& y) const { return x <= y; }
- };
- //逻辑运算
- template <class T>
- struct logical_and : public binary_function<T, T, bool>{
- bool operator()(const T& x, const T& y) const { return x && y; }
- };
- template <class T>
- struct logical_or : public binary_function<T, T, bool>
- {
- bool operator()(const T& x, const T& y) const { return x || y; }
- };
- //绑定第一个参数
- template <class Operation>
- class binder1st: public unary_function<typename Operation::second_argument_type, typename Operation::result_type> {
- public:
- binder1st(const Operation& x, const typename Operation::first_argument_type& y) : op(x), value(y) {} //构造函数
- typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const {
- return op(value, x); //固定第一个参数
- }
- protected:
- Operation op;
- typename Operation::first_argument_type value;
- };
- //绑定第二个参数
- template <class Operation>
- class binder2nd: public unary_function<typename Operation::first_argument_type,typename Operation::result_type> {
- 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); //固定第二个参数
- }
- protected:
- Operation op;
- typename Operation::second_argument_type value;
- };
- //外部接口
- template <class Operation, class T>
- inline binder1st<Operation> bind1st(const Operation& fn, const T& x) {
- typedef typename Operation::first_argument_type Arg1_type;
- return binder1st<Operation>(fn,Arg1_type(x));
- }
- //外部接口
- template <class Operation, class T>
- inline binder2nd<Operation> bind2nd(const Operation& fn, const T& x) {
- typedef typename Operation::second_argument_type Arg2_type;
- return binder2nd<Operation>(fn, Arg2_type(x));
- }
- //一元操作求反
- template <class Predicate>
- class unary_negate: public unary_function<typename Predicate::argument_type, bool> {
- protected:
- Predicate pred;
- public:
- explicit unary_negate(const Predicate& x) : pred(x) {}
- bool operator()(const typename Predicate::argument_type& x) const {
- return !pred(x);
- }
- };
- //二元操作求反
- template <class Predicate>
- class binary_negate : public binary_function<typename Predicate::first_argument_type, typename Predicate::second_argument_type,bool> {
- protected:
- Predicate pred;
- public:
- explicit binary_negate(const Predicate& x) : pred(x) {}
- bool operator()(const typename Predicate::first_argument_type& x, const typename Predicate::second_argument_type& y) const {
- return !pred(x, y);
- }
- };
- //外部接口
- template <class Predicate>
- inline unary_negate<Predicate> not1(const Predicate& pred)
- {
- return unary_negate<Predicate>(pred);
- }
- //外部接口
- template <class Predicate>
- inline binary_negate<Predicate> not2(const Predicate& pred)
- {
- return binary_negate<Predicate>(pred);
- }
//Functional.h
#pragma once
//用来定义一元操作的参数类别和返回值类别
template <class Arg, class Result>
struct unary_function {
typedef Arg argument_type; //内嵌型别技术
typedef Result result_type;
};
//用来定义二元操作的参数类别和返回值类别
template <class Arg1, class Arg2, class Result>
struct binary_function {
typedef Arg1 first_argument_type;
typedef Arg2 second_argument_type;
typedef Result result_type;
};
//一元操作,就两个
template <class T>
struct negate : public unary_function<T, T> {
T operator()(const T& x) const { return -x; }
};
template <class T>
struct logical_not : public unary_function<T,bool> {
bool operator()(const T& x) const { return !x; }
};
//加减乘除取模
template <class T>
struct plus : public binary_function<T, T, T> {
T operator()(const T& x, const T& y) const { return x + y; }
};
template <class T>
struct minus : public binary_function<T, T, T> {
T operator()(const T& x, const T& y) const { return x - y; }
};
template <class T>
struct multiplies : public binary_function<T, T , T> {
T operator()(const T& x, const T& y) const { return x * y; }
};
template <class T>
struct divides : public binary_function<T ,T, T> {
T operator()(const T& x, const T& y) const { return x / y; }
};
template <class T>
struct modulus : public binary_function<T, T, T> {
T operator()(const T& x, const T& y) const { return x % y; }
};
//关系运算
template <class T>
struct equal_to : public binary_function<T, T, bool> {
bool operator()(const T& x, const T& y) const { return x == y; }
};
template <class T>
struct not_equal_to : public binary_function<T, T,bool> {
bool operator()(const T& x, const T& y) const { return x != y; }
};
template <class T>
struct greater : public binary_function<T, T, bool> {
bool operator()(const T& x, const T& y) const { return x > y; }
};
template <class T>
struct less : public binary_function<T, T, bool> {
bool operator()(const T& x, const T& y) const { return x < y; }
};
template <class T>
struct greater_equal : public binary_function<T, T, bool> {
bool operator()(const T& x, const T& y) const { return x >= y; }
};
template <class T>
struct less_equal : public binary_function<T, T, bool> {
bool operator()(const T& x, const T& y) const { return x <= y; }
};
//逻辑运算
template <class T>
struct logical_and : public binary_function<T, T, bool>{
bool operator()(const T& x, const T& y) const { return x && y; }
};
template <class T>
struct logical_or : public binary_function<T, T, bool>
{
bool operator()(const T& x, const T& y) const { return x || y; }
};
//绑定第一个参数
template <class Operation>
class binder1st: public unary_function<typename Operation::second_argument_type, typename Operation::result_type> {
public:
binder1st(const Operation& x, const typename Operation::first_argument_type& y) : op(x), value(y) {} //构造函数
typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const {
return op(value, x); //固定第一个参数
}
protected:
Operation op;
typename Operation::first_argument_type value;
};
//绑定第二个参数
template <class Operation>
class binder2nd: public unary_function<typename Operation::first_argument_type,typename Operation::result_type> {
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); //固定第二个参数
}
protected:
Operation op;
typename Operation::second_argument_type value;
};
//外部接口
template <class Operation, class T>
inline binder1st<Operation> bind1st(const Operation& fn, const T& x) {
typedef typename Operation::first_argument_type Arg1_type;
return binder1st<Operation>(fn,Arg1_type(x));
}
//外部接口
template <class Operation, class T>
inline binder2nd<Operation> bind2nd(const Operation& fn, const T& x) {
typedef typename Operation::second_argument_type Arg2_type;
return binder2nd<Operation>(fn, Arg2_type(x));
}
//一元操作求反
template <class Predicate>
class unary_negate: public unary_function<typename Predicate::argument_type, bool> {
protected:
Predicate pred;
public:
explicit unary_negate(const Predicate& x) : pred(x) {}
bool operator()(const typename Predicate::argument_type& x) const {
return !pred(x);
}
};
//二元操作求反
template <class Predicate>
class binary_negate : public binary_function<typename Predicate::first_argument_type, typename Predicate::second_argument_type,bool> {
protected:
Predicate pred;
public:
explicit binary_negate(const Predicate& x) : pred(x) {}
bool operator()(const typename Predicate::first_argument_type& x, const typename Predicate::second_argument_type& y) const {
return !pred(x, y);
}
};
//外部接口
template <class Predicate>
inline unary_negate<Predicate> not1(const Predicate& pred)
{
return unary_negate<Predicate>(pred);
}
//外部接口
template <class Predicate>
inline binary_negate<Predicate> not2(const Predicate& pred)
{
return binary_negate<Predicate>(pred);
}
最后给出算法的定义。可以看到STL的精髓在于算法与容器的分开设计,通过迭代器将两者粘合在一起,实在是精妙之极。
- //Algorithm.h
- #pragma once
- //交换两个迭代器所指的元素
- template <class InputIterator1, class InputIterator2>
- inline void Iter_swap(InputIterator1 a, InputIterator2 b) {
- _Iter_swap(a, b, VALUE_TYPE(InputIterator1)); //VALUE_TYPE返回迭代器的值类型
- }
- //真正的交换函数
- template <class InputIterator1, class InputIterator2, class T>
- inline void _Iter_swap(InputIterator1 a, InputIterator2 b, T) {
- T tmp = *a;
- *a = *b;
- *b = tmp;
- }
- //条件计数
- template <class InputIterator, class Predicate, class Size>
- void Count_if(InputIterator first, InputIterator last, Predicate pred, Size& n) {
- for ( ; first != last; ++first)
- if (pred(*first))
- ++n;
- }
- //条件计数,有返回值
- template <class InputIterator, class Predicate>
- typename Iterator_traits<InputIterator>::difference_type Count_if(InputIterator first, InputIterator last, Predicate pred) {
- typename Iterator_traits<InputIterator>::difference_type n = 0;
- for ( ; first != last; ++first)
- if (pred(*first))
- ++n;
- return n;
- }
//Algorithm.h
#pragma once
//交换两个迭代器所指的元素
template <class InputIterator1, class InputIterator2>
inline void Iter_swap(InputIterator1 a, InputIterator2 b) {
_Iter_swap(a, b, VALUE_TYPE(InputIterator1)); //VALUE_TYPE返回迭代器的值类型
}
//真正的交换函数
template <class InputIterator1, class InputIterator2, class T>
inline void _Iter_swap(InputIterator1 a, InputIterator2 b, T) {
T tmp = *a;
*a = *b;
*b = tmp;
}
//条件计数
template <class InputIterator, class Predicate, class Size>
void Count_if(InputIterator first, InputIterator last, Predicate pred, Size& n) {
for ( ; first != last; ++first)
if (pred(*first))
++n;
}
//条件计数,有返回值
template <class InputIterator, class Predicate>
typename Iterator_traits<InputIterator>::difference_type Count_if(InputIterator first, InputIterator last, Predicate pred) {
typename Iterator_traits<InputIterator>::difference_type n = 0;
for ( ; first != last; ++first)
if (pred(*first))
++n;
return n;
}
本人享有博客文章的版权,转载请标明出处 http://blog.csdn.net/wuzhekai1985