OpenMP atomic on a reference type?

Question

The OpenMP standard (<= 4.0) says about atomic:

#pragma omp atomic [read | write | update | capture ] new-line
expression-stmt

where expression-stmt is an expression statement with one of the following forms:
...
If clause is update or not present:
x++;
...
In the preceding expressions:
x and v (as applicable) are both l-value expressions with scalar type.
...

So, when I interpret this correctly, the following short code snippet is illegal:

int main()
{
  int myCounter = 0;
  int& reference = myCounter;

  #pragma omp parallel for
  for (int i = 0; i < 100; ++i)
  {
    #pragma omp atomic
    reference++; // Increment through reference.
  }
  return 0;
}

Reason: According to this post, a reference (here int& reference) is not a scalar type. But the standard explicitly states that it must be one, in order to use atomic.

The code compiles with g++, without any warning (-Wall -Wextra).

My question is: Have I misunderstood the standard, or the concept of C++'s "reference type"? Or do most compilers compile this code, because otherwise the use of atomic is severely limited (basically no data on the heap could be the target of atomic, because you always need a reference or a dereferenced pointer)?

Answer 1

A reference type is not a scalar type. However, this fact has no bearing on your question. The important fact is that an expression that evaluates a reference to a scalar type is an lvalue with scalar type. To be specific, the variable reference has type int& but the expression reference has type int and value category lvalue. So yes, your program is conforming.