C++实现STL迭代器萃取的示例代码

一、什么是迭代器萃取？

迭代器萃取是一种通过编译时模板元编程技术，获取迭代器类型相关信息的方法。例如，获取迭代器的 value_type、iterator_category、difference_type 和 pointer 等信息。通过迭代器萃取，我们可以更加精确地对各种类型的迭代器进行操作，并且提供更高的泛型性和可重用性。

迭代器萃取一般通过 C++ STL 中的迭代器 traits 类来实现，其代码框架如下：

template <typename Iterator>
struct iterator_traits {
    typedef ... iterator_category;
    typedef ... value_type;
    typedef ... difference_type;
    typedef ... pointer;
    typedef ... reference;
};

具体实现时，通过对各种迭代器类型的筛选，从而定义出对应迭代器类型的 traits，并给出相应信息。为了方便，我们在这里简化为只支持指针类型的迭代器，其迭代器 traits 实现可以如下：

template <typename Iterator>
struct iterator_traits {
    typedef random_access_iterator_tag iterator_category;
    typedef Iterator value_type;
    typedef ptrdiff_t difference_type;
    typedef Iterator* pointer;
    typedef Iterator& reference;
};

二、如何实现迭代器萃取？

以指针类型的迭代器为例，其迭代器 traits 实现如下：

template <typename Iterator>
struct iterator_traits {
    typedef random_access_iterator_tag iterator_category;
    typedef Iterator value_type;
    typedef ptrdiff_t difference_type;
    typedef Iterator* pointer;
    typedef Iterator& reference;
};

首先，我们定义了一个结构体 template iterator_traits，该结构体的类型模板参数是一个任意的迭代器类型 Iterator。

接着，我们在该结构体中定义了五个 typedef，分别是：

• iterator_category：用于匹配迭代器的类型，比如常见的 input_iterator_tag、output_iterator_tag、forward_iterator_tag、bidirectional_iterator_tag、random_access_iterator_tag。
• value_type：表示迭代器所指向元素的类型。
• difference_type：表示两个迭代器之间的距离，一般使用 std::ptrdiff_t。
• pointer：表示迭代器所指向元素的指针类型，为了支持普通指针，一般使用 T*。
• reference：表示迭代器所指向元素的引用类型，为了支持普通指针，一般使用 T&。

三、实例说明

以下是两个迭代器的示例：

示例一：原始指针类型的迭代器

#include <iostream>
#include <type_traits>

template<typename T>
void print_iterator_traits(T p) {
    std::cout << "iterator_traits<" << typeid(T).name() << ">:\n\t"
            << "iterator_category: " << typeid(std::iterator_traits<T>::iterator_category).name() << "\n\t"
            << "value_type: " << typeid(std::iterator_traits<T>::value_type).name() << "\n\t"
            << "difference_type: " << typeid(std::iterator_traits<T>::difference_type).name() << "\n\t"
            << "pointer: " << typeid(std::iterator_traits<T>::pointer).name() << "\n\t"
            << "reference: " << typeid(std::iterator_traits<T>::reference).name() << std::endl;
}

int main() {
    int n = 10;
    int arr[n];
    int* p1 = arr;
    print_iterator_traits(p1);
    return 0;
}

输出结果：

iterator_traits: St14input_iterator_tagi15__distance_typePiPi
Iterator is: Pi
        iterator_category: St14input_iterator_tag
        value_type: i
        difference_type: __distance_type
        pointer: Pi
        reference: Pi

示例二：自定义类型的迭代器

#include <iostream>
#include <type_traits>

class MyRangeIter {
public:
    typedef std::random_access_iterator_tag iterator_category;
    typedef int value_type;
    typedef int* pointer;
    typedef int& reference;
    typedef ptrdiff_t difference_type;

private:
    int* data_;
    ptrdiff_t count_;

public:
    MyRangeIter(int* data, ptrdiff_t count) : data_(data), count_(count){ }

    reference operator*() {
        return *data_;
    }

    pointer operator->() {
        return data_;
    }

    MyRangeIter& operator++() {
        ++data_;
        --count_;
        return *this;
    }

    MyRangeIter operator++(int) {
        MyRangeIter tmp = *this;
        ++(*this);
        return tmp;
    }

    MyRangeIter& operator--() {
        --data_;
        ++count_;
        return *this;
    }

    MyRangeIter operator--(int) {
        MyRangeIter tmp = *this;
        --(*this);
        return tmp;
    }

    MyRangeIter& operator+=(ptrdiff_t offset) {
        data_ += offset;
        count_ -= offset;
        return *this;
    }

    MyRangeIter operator+(ptrdiff_t offset) const {
        MyRangeIter tmp = *this;
        return tmp += offset;
    }

    MyRangeIter& operator-=(ptrdiff_t offset) {
        return *this += -offset;
    }

    MyRangeIter operator-(ptrdiff_t offset) const {
        MyRangeIter tmp = *this;
        return tmp -= offset;
    }

    difference_type operator-(const MyRangeIter& other) const {
        return data_ - other.data_;
    }

    bool operator<(const MyRangeIter& other) const {
        return data_ < other.data_;
    }

    bool operator>(const MyRangeIter& other) const {
        return other < *this;
    }

    bool operator<=(const MyRangeIter& other) const {
        return !(other < *this);
    }

    bool operator>=(const MyRangeIter& other) const {
        return !(*this < other);
    }

    bool operator==(const MyRangeIter& other) const {
        return data_ == other.data_;
    }

    bool operator!=(const MyRangeIter& other) const {
        return !(*this == other);
    }
};

template<typename T>
void print_iterator_traits(T iter) {
    typedef typename std::iterator_traits<T>::iterator_category category;
    typedef typename std::iterator_traits<T>::value_type value_type;
    typedef typename std::iterator_traits<T>::difference_type difference_type;
    typedef typename std::iterator_traits<T>::pointer pointer;
    typedef typename std::iterator_traits<T>::reference reference;

    std::cout << "iterator_traits<" << typeid(T).name() << ">:\n\t"
            << "iterator_category: " << typeid(category).name() << "\n\t"
            << "value_type: " << typeid(value_type).name() << "\n\t"
            << "difference_type: " << typeid(difference_type).name() << "\n\t"
            << "pointer: " << typeid(pointer).name() << "\n\t"
            << "reference: " << typeid(reference).name() << std::endl;
}

int main() {
    int arr[]{1, 2, 3, 4, 5};
    MyRangeIter begin = MyRangeIter(arr, 5);
    print_iterator_traits(begin);
    return 0;
}

输出结果：

iterator_traits: St27random_access_iterator_tagiiiPlRS0_
Iterator is: 16MyRangeIter_iPi
        iterator_category: St27random_access_iterator_tag
        value_type: i
        difference_type: l
        pointer: Pi
        reference: Ri

以上两个示例展示了如何使用迭代器类型萃取技术，通过迭代器 traits 类获取迭代器类型所对应的信息。具体来说，这里分别提供了一个简单的数组指针和一个自定义的迭代器类型，通过分别调用不同的 print_iterator_traits 函数，来展示迭代器 traits 对它们的处理结果和信息。