get the index of a C++ foreach item in a debugger

Question

Lets assume the code doesn't need the index, but something interesting happened during debugging and I want to know the position of the item in the container.

for (int item : myarray)
    doSomething(item); // <-- breakpoint/exception/assertion; what index was 'item'?

Lets assume it's a random access containers where it should still be resonable to find the answer at runtime. Is this possible? Can it be possible?

It'd be really convenient if we could e.g. hover over for and see the current iterator and its distance to the container's begin().

If item were a reference I could make a risky guess that the index is &item - &myarray[0]. Although it'd be a pain to type every time I wanted to check during debugging.

---

To clarify, there are many questions about getting the index in the code (interesting references here and here). Instead I want the index in the debugger. Maybe I didn't write the code, can't easily recompile or a repro is highly intermittent. It's perfectly reasonable to not want the index in the code because it can add clutter and confusion when it's not needed. Constructs such as std::views::zip and std::views::enumerate will make working without indices easier. That said, we currently lose debugging information when buying into these features.

Answer 1

Just in case when intention is to implement some functionality iterrable by foreach, and need to keep track of the current iteration. Starting from the simple idea of using pointers:

class myarray {
    int x[5] = { 1, 2, 3, 4, 5 };
public:
    int* begin() { return x; }
    int* end() { return x + 5; }
};

int main() {
    for (auto x : a) cout << x << endl;
    return 0;
}

The foreach will advance the pointer returned by begin calling operator ++.
So we wrap the concept of pointer in the concept of iterator to keep track of position:

class myarray {
    int x[5] = { 1, 2, 3, 4, 5 };
public:
    //put breakpoint anywhere inside a function of this class:
    class iterator {
        int* p0, *p;
    public:
        iterator(int* _p) : p(_p), p0(_p) {}
        int& operator*() { return *p; }
        iterator& operator++() { ++p; std::cout << "position "<< position() << std::endl; return *this; }
        size_t position() { return p - p0; }
        bool operator!=(const iterator& other) const { return p != other.p; }
    };
    iterator begin() { return iterator(x); }
    iterator end() { return iterator(x + 5); }

};
....
In the nested class iterator you can give as much control over iterations as you like.

Now this will be the output:

[]
For different cases any other container specific iterator and position calculation can be implemented.

(https://i.sstatic.net/8M2bVLvT.png)