C++ 基于范围的for循环索引

std:：vector上的自定义迭代器返回以下类的对象：

class chunk {
public:
    int    value_;
    size_t fake_index_;
};

迭代器同时更新

伪索引和
值

之后，我用迭代器创建了一个range类。然后，在range类上循环的range base中，我只使用
值，而不使用
伪索引

这是否意味着编译器将优化迭代器对
伪索引的更新

测试代码（包含所有迭代器内容…）

#包括
#包括
类迭代器；
类块{
公众：
int值；
int base_bit_index_；
整数实指数；
标准：：向量和数据；
块（标准：：向量和数据，大小\u t实际\u索引）
：data{data}
{
基本位索引=实际索引*sizeof（int）；
真实指数=真实指数；
值=数据[实际指数]；
}
int value（）{返回值}
私人：
无效增量_索引（）{
++真实指数；
基本位索引=sizeof（int）；
值=数据[实际指数]；
}
友元类迭代器；
};
类迭代器：public std:：Iterator
{
私人：
语块；
公众：
迭代器（块）：块（块）{
迭代器（const Iterator&mit）：块{（mit.chunk{}
迭代器和运算符++（）{
块增量索引（）；
归还*这个；
}
迭代器运算符++（int）{Iterator tmp（*this）；运算符++（）；返回tmp；}
布尔运算符==（常量迭代器和rhs）
{
返回chunk.real\u index\u==rhs.chunk.real\u index；
}
布尔运算符！=（常量迭代器和rhs）
{
返回！（运算符==（rhs））；
}
块和运算符*（）{返回块}
};
等级范围
{
私人：
标准：：向量和数据；
公众：
范围（标准：：矢量和数据）
：data{data}
{
}
迭代器begin（）
{
块块（数据0）；
迭代器tmp（块）；
返回tmp；
}
迭代器结束（）
{
块块（数据，数据大小（））；
迭代器tmp（块）；
返回tmp；
}
};
int main（）
{
std：：向量v1；
v1.调整大小（100）；
std：：向量v2；
范围X（v1）；
用于（自动块：X）{
v2.向后推（chunk.real\u index）；
}
}


测试代码（没有所有迭代器的东西）

#包括
#包括
int main（）
{
std：：向量v2；
对于（尺寸i=0；i<100；++i）{
v2.推回（i）；
//std：：cout仅提供代码无法知道。我们可以看看更新代码是什么样子吗？类似于
chunk\uu.fake\u index\uu+=8*sizeof（int）
对于迭代器的每个
++
操作。如果没有答案，我想我将继续编写测试代码。在gcc god bolt中检查它，然后看看是否应该编写实际代码。
#include <vector>
#include <iterator>

class Iterator;

class Chunk {

public:
    int value_;
    int base_bit_index_;
    int real_index_;
    std::vector<int>& data_;
    Chunk (std::vector<int>& data, size_t real_index)
            : data_{data}
    {
        base_bit_index_ = real_index*sizeof(int);
        real_index_ = real_index;
        value_ = data[real_index_];
    }
    int value() { return value_; }
private:
    void increment_index() {
        ++real_index_;
        base_bit_index_ += sizeof(int);
        value_ = data_[real_index_];
    }
    friend class Iterator;
};

class Iterator : public std::iterator<std::input_iterator_tag, int>
{
private:
    Chunk chunk_;
public:
    Iterator(Chunk chunk) :chunk_(chunk) {}
    Iterator(const Iterator& mit) : chunk_(mit.chunk_) {}
    Iterator& operator++() {
        chunk_.increment_index();
        return *this;
    }
    Iterator operator++(int) {Iterator tmp(*this); operator++(); return tmp;}
    bool operator==(const Iterator& rhs)
    {
        return chunk_.real_index_== rhs.chunk_.real_index_;
    }
    bool operator!=(const Iterator& rhs)
    {
        return !(operator==(rhs));
    }
    Chunk& operator*() {return chunk_;}
};
class Range
{
private:
    std::vector<int>& data_;
public:
    Range(std::vector<int>& data)
        : data_{data}
    {
    }
    Iterator begin()
    {
        Chunk chunk(data_, 0);
        Iterator tmp(chunk);
        return tmp;
    }
    Iterator end()
    {
        Chunk chunk(data_, data_.size());
        Iterator tmp(chunk);
        return tmp;
    }
};
int main()
{
    std::vector<int> v1;
    v1.resize(100);
    std::vector<int> v2;
    Range X(v1);
    for (auto chunk : X) {
        v2.push_back(chunk.real_index_);
    }
}

#include <vector>
#include <iostream>
int main()
{
    std::vector<int> v2;
    for (size_t i = 0; i < 100; ++i) {
        v2.push_back(i);
        // std::cout<<i<<"\n";
    }
}