Well, I rarely have more than 2^31 elements in a container. In any case, just use gsl::index, as I mentioned, which is just a std::ptrdiff_t, which is (usually) a 64-bit int.

That’s fine if the number of elements in the container is within the positive range of an int. However if there are more elements than this then having i as type size_t is correct. Also it’s probably better to have the index i in its own block such as

{
     int i = -1;
        for (auto const& elem : container)
        {
         ++i;
                // do stuff
        }
}

As mentioned by Paul Baxter, Therocode’s “enumerate” seems to do just that : https://blog.therocode.net/2018/10/for-each-with-index

Yep, great idea! Would you like to try and code it up to see what this would look like?

    for (const auto& [index, word] : words | indexed(1))
    {
        std::cout << index << " - " << word << 'n';
    }

Unfortunately, this doesn’t seem to work with boost indexed, but a modified version of it would work, if the dereferenced iterator would return a struct or standard pair or tuple.

 
    size_t i = 0;
    for (auto cons& elem : container)
    {
        // do stuff
        ++i;
    }
 

The problem is that if there is a “continue” statement in the “do part”. In normal for loops when you continue the “add one” part still executes. But here it doesn’t. So I find this a bit better:

 
    int i = -1;
    for (auto cons& elem : container)
    {
        ++i;
        // do stuff
    }
 

Well, in general one could use gsl::index or something similar instead of an int. Just not an unsigned type such as size_t