Question

我最近想知道如何进行远程工作，最终得到如下图：

for(obj& temp_ref:range r)//hide iterator somewhere as the range defined.

对于每一次迭代，只有一个当前对象的更新才能完成一个循环，这对我来说是很不错的解释。

但是当我尝试将范围和迭代器组合成一个混合类时，
这里有一个问题，应该在我的代码中调用哪个operator ++，
从某种意义上讲，应该是在基于范围的for中调用派生类方法，
因为我将对象创建为派生对象，所以我的声明是虚拟的。

此处提供了代码，第一部分是正确的且有小节，但是第二个对我来说很奇怪。

#include <iostream>

namespace first
{
        template<class iterator>
        class range
        {
            public:
                range(iterator ina,iterator inb):a(ina),b(inb){};
                iterator a,b;
                iterator& begin(){return a;};
                iterator& end(){return b;};
        };
        template<class T>
        class iterator
        {
            public:
                iterator(T* ini):i(ini){};
                T* i;
                virtual iterator<T>& operator= (const iterator<T>& other){this->i=other.i;return *this;};
                virtual T& operator* (){return *i;};
                virtual T operator!= (const iterator<T>& other){return this->i==other.i?0:1;};
                virtual void operator++ (){i++;};
        };
        class jump2:public iterator<int>
        {
            public:
                jump2(int* ini):iterator<int>(ini){};
                virtual void operator++ (){i+=2;};
        };

}

namespace second
{
    template<class T>
    class iterator
    {

        public:
            iterator(T* inStart,T* inFinal):current(inStart),final(inFinal){};
            T* current;
            T* final;
            iterator<T> begin(){return iterator<T>(this->current,this->final);};
            iterator<T> end(){return iterator<T>(this->final,this->final);};
            virtual iterator<T>& operator= (const iterator<T>& other){this->current=other.current;this->final=other.final;return *this;};
            virtual T& operator* (){return *this->current;};
            virtual bool operator!= (iterator<T>& other){return this->current!=other.final;};



            virtual void operator++ ()
            {
                std::cout<<"<call base>";
                this->current=this->current+1;
            };



    };
    template<class T>
    class jumper:public iterator<T>
    {
        public:

            jumper(T* inStart,T* inFinal):iterator<T>(inStart,inFinal){};



            void operator++ ()
            {
                std::cout<<"<call deri>";
                this->current=this->current+2;
            };



    };
};

int main()
{

    int a[6]={1,0,2,0,3,0};

    //success
    {
        using namespace first;

        range<jump2> a_range(jump2(a),jump2(a+6));


        for(int store:a_range)
            std::cout<<store<<std::endl;
    }//pause();


    //Fail
    {
        using namespace second;

        jumper<int> a_iterator_call_jumper(a,a+6);

        for(int& i:a_iterator_call_jumper)
            std::cout<<i<<std::endl;

    }//pause();



    return 0;
};

此输出为

1
2
3
1
<call base>0
<call base>2
<call base>0
<call base>3
<call base>0
<call base>

但是应该像

1
2
3
1
<call deri>2
<call deri>3
<call deri>

这是因为我用错了吗？
还是找不到我的错误？

Answer 1

    template<class iterator>
    class range
    {
        public:
            range(iterator ina,iterator inb):a(ina),b(inb){};
            iterator a,b;
            iterator& begin(){return a;};
            iterator& end(){return b;};
    };

否

    template<class iterator>
    class range
    {
        public:
            range(iterator ina,iterator inb):a(ina),b(inb){};
            iterator a,b;
            iterator begin() const {return a;};
            iterator end() const {return b;};
    };

是。

    template<class T>
    class iterator
    {
        public:
            iterator(T* ini):i(ini){};
            T* i;
            virtual iterator<T>& operator= (const iterator<T>& other){this->i=other.i;return *this;};
            virtual T& operator* (){return *i;};
            virtual T operator!= (const iterator<T>& other){return this->i==other.i?0:1;};
            virtual void operator++ (){i++;};
    };

否

    template<class T>
    class iterator
    {
        public:
            iterator(T* ini):i(ini){};
            T* i;
            iterator( iterator const& ) = default;
            iterator& operator= (const iterator<T>& other) & = default;
            T& operator*() {return *i;};
            bool operator!= (const iterator& other) const {return this->i==other.i?0:1;};
            void operator++() {++i;};
    };

是。

不要将基于C ++ vtable的标准多态对象模型用于迭代器；它们应该是常规类型，并且基于vtable的多态对象模型不是常规。

对于second，这不是一个好计划。迭代器和要迭代的范围不是同一回事。将它们粉碎在一起会使您的班级变得不连贯。

C ++迭代不适用于动态调度（多态）。您可以做到，但是却会降低性能，而且编写也不容易。基本上，您需要将虚拟分派隐藏在常规类型的后面（可以使用vtables分派，也可以使用C ++基于空指针的类型擦除进行分派）。

如果您习惯于其他语言，则许多其他C ++衍生语言都将强制性引用语义与垃圾回收一起用于类类型的对象。他们的虚拟继承对象模型适用于引用变量，就像在C ++中使用引用和指针类型一样。

C ++相对古怪（在当今时代），因为它支持将复杂的对象作为值类型，并且假定语言和标准库大多数时候都在使用值类型。（请注意，指针是一种值类型；但是它的值是指针，而不是对象），并且当您要使用引用/指针语义时，必须调整代码。

什么是“基于范围的”迭代调用

1 个答案: