Is it possible to ban modifying loop variables inside the body of for-loops?

Question

In C or C++, modifying loop variables inside the for-loops is a source of nasty bugs:

int main() {
    std::vector<int> v (30);
    std::iota(v.begin(), v.end(), 0);
    int j = 0;
    for (size_t i = 0; i < v.size(); i++) {
        std::cout << v[i] << ' ' << i << '\n';
        i++; // oops, I mean j++
    }
    std::cout << j << '\n';
}

Is there any way to ban or get warning modifying loop variables inside loop bodies with aid of compilers or something? If it is possible, how can I do so?

Answer 1

If you use a C++ ranged-for, you can make the loop variable const. e.g.

for (const size_t i : boost::irange<size_t>(0, v.size()))
{
    std::cout << v[i] << ' ' << i << '\n';
    // i++; // error, can't modify const
}

Answer 2

For C++ you could create an index class to use. So something along the lines of the following would be a starting place. I'm sure that it can be improved as I haven't put much thought into it.

class CIndex {
private:
    size_t  m_index;
public:
    CIndex(size_t i=0) : m_index(i) {}
    ~CIndex() {};

    size_t inc(void) { return ++m_index; }
    size_t val(void) { return m_index; }

    bool operator < (size_t i) { return m_index < i; }
    CIndex & operator =(size_t i) = delete;
};

and it would be used something like:

for (CIndex x; x < 10; x.inc()) {
    std::cout << argv[x.val()];
    x = 3;    // generates an error with Visual Studio 2017
}

You could modify the above class with a conversion operator to make it a bit more intuitive and similar to a standard size_t variable. Also add a decrement operator as well. Since the idea is to use this in place of a size_t you no longer need the comparison operator since the compiler will do the conversion and use built in comparison for loop end. You may also want to be able to specify an optional increment or decrement amount.

The modified class would look like:

class CIndex {
private:
    size_t  m_index;
public:
    CIndex(size_t i = 0) : m_index(i) {}
    ~CIndex() {};

    size_t inc(size_t i = 1) { return (m_index += i); }    // increment operator
    size_t dec(size_t i = 1) { return (m_index -= i); }    // decrement operator

    CIndex & operator =(size_t i) = delete;
    operator size_t() const { return m_index; }
};

This would allow you to use the CIndex pretty much anywhere a size_t could be used. So an array index could be written as std::cout << argv[x]; rather than std::cout << argv[x.val()];.

However for C this is nothing within the language specification that allows you to mark a variable as immutable or unchanging within a particular scope.

What you are really asking for is to be able to mark particular lines of code to allow a variable to be changed and to mark other lines of code where the variable is not allowed to be changed. The C language specification does not have that feature.

Answer 3

In C, you could hide the name and redeclare another identifier with the same name as const, but you will need to use some intermediate object to help, and it is not pretty:

for (int i = 0; i < 10; ++i)
{
    const int t = i, i = t;
    printf("i = %d.\n", i);  // Works.
    i = 4;                   // Yields compiler error.
}

I do not recommend this, but you can make it somewhat less ugly with:

#define Protect(Type, Original) \
    const Type Auxiliary_##Original = Original, Original = Auxiliary_##Original

and then use:

for (int i = 0; i < 10; ++i)
{
    Protect(int, i);
    printf("i = %d.\n", i);  // Works.
    i = 4;                   // Yields compiler error.
}

Answer 4

EDIT: To answer your latest comment:

Yes, what I'm looking for was just if there is a compiler option that warns it. If there isn't, maybe I should just code more carefully.

No, in C there unfortunately isn't. Yes, you should code more carefully. In general, I would suggest you to think about why you would want to have such feature. If "protecting" index variables inside loops is a concern, I would first ask myself if my coding style makes sense and is consistent.

---

As Eric Postpischil noticed, you can just use a temporary variable to shadow your index variable inside an inner block as const. This way the compiler will error-out if you try to modify it.

This however produces shadowing warnings (in particular with the -Wshadow flag, which is pretty common):

shadow.c:9:14: warning: declaration of ‘i’ shadows a previous local [-Wshadow]
    const int i = t;
              ^
shadow.c:4:11: note: shadowed declaration is here
  for (int i = 0; i < 10; ++i)

To avoid this, you can use simple diagnostic #pragma directives and temporarily disable the warning for that specific code block:

for (int i = 0; i < 10; ++i)
{
    const int t = i;
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wshadow"
    {
        const int i = t;
        printf("i = %d\n", i);
        i = 4; // Will yield a compiler error.
    }
    #pragma GCC diagnostic pop
}

The above code works (removing the i = 4 of course) and compiles without warnings using -Wall -Werror -Wshadow -pedantic in both GCC and Clang.

NOTE: this surely is no good practice, but AFAICT it's the only way to achieve such behavior in C.