C++学习笔记-迭代器(iterator)与萃取机(traits）

void test_find(){
    const int arraySize = 10;
    int num[arraySize] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    vector <int> vec(num, num + arraySize);
    vector <int> ::iterator it1 = find(vec.begin(), vec.end(), 8);
    if (it1 == vec.end()){
        cout << "not found" << endl;
    }else{
        cout << "found it :" << *it1 << endl;
    }

    list <int> lis(num, num + arraySize);
    list <int>::iterator it2 = find (lis.begin(), lis.end(), 4);
    if (it1 == vec.end()){
        cout << "not found" << endl;
    }else{
        cout << "found it :" << *it2 << endl;
    }

    deque <int> deq(num, num + arraySize);
    deque <int>::iterator it3 = find (deq.begin(), deq.end(), 5);
    if (it3 == deq.end()){
        cout << "not found" << endl;
    }else{
        cout << "found it :" << *it3 << endl;
    }
}

template <class T>
class auto_ptr{
public:
    explicit auto_ptr(T *p = 0) : pointee(p){} //普通构造函数
    template <class U>
    auto_ptr(auto_ptr<U>& rhs) : pointee(rhs){} //拷贝构造
    template <class U>
    auto_ptr& operator= (auto_ptr<U>& rhs){
        if (this != &rhs) reset(rhs.release);
        return *this;
    }
    ~auto_ptr() {delete pointee;}
    //最关键的两个
    T& operator*() const {return *pointee;}
    T* operator->() const {return pointee;}
private:
    T* pointee;
};



//调用
auto_ptr<string> ps (new string("ss"));
cout << *ps << endl; //输出ss;
//string可以换成自己的自定义类；

ListIter <ListItem<int>> begin(mylist.front());
//ListIter是迭代器类，，ListItem<int>是一个单向链表类，mylist是直接定义的一个基于单链表的容器
//这样说明，begin就是指向自定义容器第一个位置的指针，是不是类似于：vector<int>::iterator ite = vec.begin();

template <class T>
struct MyIter{
    typedef T value_type; 内嵌类型
    T* ptr;
    MyIter(T* p = 0): ptr(p){}
    T& operator*()const {return *ptr;}
};


template <class I>
typename I::value_type  //这一行都是func的返回类型(因为I是一个template参数，在编译器具现之前，编译器对I一无所知，使用typename可以告诉编译器这是一个类型
func(I ite){
    return *ite;
}

//个数上的特化
//比如泛化模板如：
template<class T, class U, class V>//这是一种泛化
//个数上的特化就是让一个值有默认值，比如：
template<class T, class U, class V == string>

//类型上的特化
//比如一个模板
template <class T>
class Demo <T*>{}//这就是类型上的特化，只接受原生指针；

// 用于traits出迭代其所指对象的型别
template <class Iterator>那
struct iterator_traits
{
  // 迭代器类型, STL提供五种迭代器
  typedef typename Iterator::iterator_category iterator_category;

  // 迭代器所指对象的型别
  // 如果想与STL算法兼容, 那么在类内需要提供value_type定义
  typedef typename Iterator::value_type        value_type;

  // 这个是用于处理两个迭代器间距离的类型
  typedef typename Iterator::difference_type   difference_type;

  // 直接指向对象的原生指针类型
  typedef typename Iterator::pointer           pointer;

  // 这个是对象的引用类型
  typedef typename Iterator::reference         reference;
};
// 针对指针提供特化版本
template <class T>
struct iterator_traits<T*>
{
  typedef random_access_iterator_tag iterator_category;
  typedef T                          value_type;
  typedef ptrdiff_t                  difference_type;
  typedef T*                         pointer;
  typedef T&                         reference;
};

// 针对指向常对象的指针提供特化
template <class T>
struct iterator_traits<const T*>
{
  typedef random_access_iterator_tag iterator_category;
  typedef T                          value_type;
  typedef ptrdiff_t                  difference_type;
  typedef const T*                   pointer;
  typedef const T&                   reference;
};

template <class T, class V>
typename iterator_traits<I>::difference_type //返回值
count(T first, I last, const T& value){
    //统计容器里value的个数
    typename iterator_traits<I>::difference_type n = 0; 
    //这里就是回答，因为迭代器I可以通过萃取机萃取出需要的difference_type,如果通过::出不来类型，那就是回答不了。
    ...
    return n;
}