迭代器继承和继承 *this

Question

如何编写一个基类和几个派生类的迭代器？

迭代器是否必须返回自身（*this）？

到目前为止，我使用typename X 和static_cast<X&>(*this) 来允许派生类继承从基类返回自身的函数。

This 看起来很丑。有没有更好的办法？

简化代码：

#include <iterator>
#include <iostream>
template <typename T, typename X>
class BaseIterator : public std::iterator<std::input_iterator_tag, T> {
    //Not intended to be used directly.
    private:
        T* p;
    protected:
        virtual void increment(void)=0;
        virtual T* stride_index(int index)=0;
    public:
        virtual ~BaseIterator(){} //virtual destructor.
        X operator++(int) { //takes a dummy int argument
            X tmp(static_cast<X&>(*this) );
            increment();
            return tmp;
        }
        bool operator==(const X & rhs) { return p==rhs.p; }
} ;
template <typename T>
class ContiguousIterator : public BaseIterator<T, ContiguousIterator<T> > {
    private:
        T* p;
    protected:
        inline void increment(void) {++p;}
        inline T* stride_index(int index){return p + index;}
    public:
        virtual ~ContiguousIterator(){} //destructor.
        ContiguousIterator(T* x) :p(x) {}
        ContiguousIterator(const ContiguousIterator<T> & mit) : p(mit.p) {}
} ;

int main(void){
    int i[]={0,1,2,3,4,5};
    ContiguousIterator<int> itbegin(i);
    ContiguousIterator<int> it(i);
    it++;
    std::cout << "result: " << (it == itbegin) << std::endl;
}

另一种方法是忘记使用继承来编写更少的代码。只需将返回 *this 的函数复制并粘贴到派生类即可。

我似乎越来越能接受这种选择......

Answer 1

一般来说，virtual 对于应该是轻量级的迭代器之类的东西来说是很多开销。通常的方法是 CRTP。这有点棘手，但看起来像这样：

template <typename T, typename X>
class BaseIterator : public std::iterator<std::input_iterator_tag, T> {
    protected:
        T* p;
        X* self() {return static_cast<X*>(this);}
        const X* self() const {return static_cast<const X*>(this);}
        BaseIterator(T* x) :p(x) {}
    public:
        X operator++(int) { //takes a dummy int argument
            X tmp(*self());
            self()->increment();
            return tmp;
        }
        bool operator==(const X & rhs) const { return p==rhs.p; }
} ;

基类通常采用派生类型，加上函数签名所需的任何东西作为模板参数。然后添加两个self() 函数，它们为您提供派生类型，这意味着您实际上不需要virtual。一切都被编译器简单地内联。 （注意我也给了它一个理智的构造函数，并制作了operator==const。

template <typename T>
class ContiguousIterator : public BaseIterator<T, ContiguousIterator<T> > {
    public:
        typedef BaseIterator<T, ContiguousIterator<T> > parent;
        void increment(void) {++(this->p);}
        T* stride_index(int index) const {return this->p + index;}
    public:
        virtual ~ContiguousIterator(){} //destructor.
        ContiguousIterator(T* x) :parent(x) {}
        ContiguousIterator(const ContiguousIterator<T> & mit) : parent(mit.p) {}
} ;

然后派生类型简单地继承正常，除了你必须使用this-> 来访问成员，因为父是一个模板。在这里看到它的工作：http://coliru.stacked-crooked.com/a/81182d994c7edea7

这产生了一个高效的迭代器，没有开销。我相信这种技术在 Boost 的迭代器库中被大量使用：http://www.boost.org/doc/libs/1_59_0/libs/iterator/doc/#new-style-iterators