基于范围的 for 在数组 ODR 上循环使用该数组吗？

Question

When a range based for loop is used to iterate over an array, without binding a reference to each element, does this constitute an ODR-use of the array?

Example:

struct foo {
    static constexpr int xs[] = { 1, 2, 3 };
};

int test(void) {
    int sum = 0;
    for (int x : foo::xs) // x is not a reference!
        sum += x;
    return sum;
}

// Definition, if needed
///constexpr foo::xs;

Is the definition of foo::xs necessary?

While this code, and variations of it, appear to work fine, that doesn't mean the definition is never necessary. Lack of a definition of an ODR-used variable rarely produces a diagnostic, since the variable could be defined in another translation unit. A linker error is the usual result, but it's quite possible to not get the error if the compiler is able to optimize away every use, which is what happens to the above code. The compiler effectively reduces test() to return 6; .

Binding a reference to an element would be an ODR-use, but that isn't done.

I was under impression that subscripting an array was not ODR-use in C++14 or later. But the range based for is not exactly subscripting.

In C++17, I believe this example avoids the problem because constexpr class data members are implicitly inline. And thus the declaration in the class also serves to define xs and an additional namespace scope definition isn't needed to satisfy ODR.

Some additional versions of the same question:

What if we use std::array ?

constexpr std::array<int, 3> xs = { 1, 2, 3 };

What if we avoid the range based for?

for (int i = 0; i < foo::xs.size(); i++) sum += foo::xs[i];

Answer 1

Is the definition of foo::xs necessary?

Yes, because as NathanOliver points out in the comments, a reference is implicitly bound to foo::xs by the range-based for loop. When you bind a reference to an object, the object is odr-used. The same would occur if an std::array were used rather than a raw array.

What if we avoid the range based for?

Well, if you use a raw array and get its size using a technique that doesn't require binding a reference to it, then you can avoid providing a definition:

for (int i = 0; i < sizeof(foo::xs)/sizeof(foo::xs[0]); i++) {
    sum += foo::xs[i];
}

In this case, the references inside sizeof are not odr-uses because they are unevaluated, and foo::xs is an element of the set of potential results of foo::xs[i] ; this latter expression is of non-class type and immediately undergoes an lvalue-to-rvalue conversion, so it does not odr-use foo::xs .