Range based for loop index - c++

Question

A custom iterator on a std::vector returns an object of the following class:
class chunk {
public:
int value_;
size_t fake_index_;
};
The iterator updates both the fake_index_ and value_.
After that I create a range class with the iterator. Then in a range base for loop over the range class, I only use the value_, but not fake_index_.
Does that means the compiler will optimize out the iterator's update of fake_index_ ?
Test Code (with all the iterator stuff...)
#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_);
}
}
gcc godbolt
Test Code (without all the iterator stuff)
#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";
}
}
gcc godbolt
My first impression: Looks like the iterator sucks horribly anyway.