C++ 实现昂贵的c++；迭代器

假设我们有这样的课：

#include <cstdio>

struct A{
    struct it{
        it(int i) : i(i){
            printf("c-tor %d\n", i);
        }

        it &operator++(){
            i++;
            return *this;
        }

        int operator*(){
            return i;
        }

        bool operator!=(const it &ot){
            return i != ot.i;
        }

        int i;
    };

    it begin() const{
        return it(0);
    }

    it end() const{
        return it(10);
    }

    it end_it = it(10);

    const it &xend() const{
        return end_it;
    }

};

int main(){
    A a;

    printf("for\n");
    for(A::it i = a.begin(); i != a.end(); ++i)
        printf("%d\n", *i);


    printf("c++11 for\n");
    for(int j : a)
        printf("%d\n", j);


    printf("memoize\n");
    A::it my_end = a.end();

    for(A::it i = a.begin(); i != my_end; ++i)
        printf("%d\n", *i);


    printf("ref\n");
    for(A::it i = a.begin(); i != a.xend(); ++i)
        printf("%d\n", *i);
}

#包括
结构A{
构造它{
it（int i）：i（i）{
printf（“c-tor%d\n”，i）；
}
it&operator++（）{
i++；
归还*这个；
}
整型运算符*（）{
返回i；
}
布尔运算符！=（常数it&ot）{
返回i！=ot.i；
}
int i；
};
它开始（）常量{
返回它（0）；
}
它结束（）常量{
退回（10）；
}
it end_it=it（10）；
常量it&xend（）常量{
返回结束它；
}
};
int main（）{
A A；
printf（“for\n”）；
对于（A：：it i=A.begin（）；i！=A.end（）；++i）
printf（“%d\n”，*i）；
printf（“c++11代表\n”）；
对于（int j:a）
printf（“%d\n”，j）；
printf（“memoize\n”）；
A：：it my_end=A.end（）；
对于（A：：it i=A.begin（）；i！=my_end；++i）
printf（“%d\n”，*i）；
printf（“ref\n”）；
对于（A:：it i=A.begin（）；i！=A.xend（）；++i）
printf（“%d\n”，*i）；
}

编辑：迭代器是常量迭代器。在这个例子中是非常简单的，这是不明显的

当我们对循环进行第一次迭代时，将为每个循环迭代构造新的结束迭代器

如果我们将类从end（）分配给变量（例如memoize），则不存在此类问题

C++11可能也在做同样的事情

最后，

end（）

实现昂贵迭代器的正确方法是什么？
请参阅Herb Sutter的GotW on。他建议在进入循环之前只能调用一次
end（）
，避免每次迭代都调用
end（）

但是，他建议测量迭代器临时创建是否是性能瓶颈（例如，它可能非常快，甚至可能由编译器优化），以避免过早优化

定义：过早优化是指在没有实际需要的数据的情况下，以效率的名义使代码更加复杂

如果不修改容器，则可能希望在进入循环之前只调用一次
end（）
。另请参见“是”，这是常量迭代器，我将编辑问题。如果修改容器（而不是容器的内容），迭代器的常量几乎没有什么作用