Re: closure type for lambda-expressions and constness
On 20 Apr., 23:06, Paul Bibbings wrote:
[...]
double sum = 0;
std::for_each(d_array,
d_array + 4,
[=](double d) { // error: no=
t mutable
sum += d;
});
[...]
double sum = 0;
std::for_each(d_array,
d_array + 4,
[&](double d) { // OK: not mutable?
sum += d;
});
and certainly gcc-4.5.0 agrees:
21:47:59 Paul Bibbings@JIJOU
/cygdrive/d/CPPProjects/CLCPPM $i686-pc-cygwin-gcc-4.5.0 -std=c+=
+0x
-pedantic -c non_mutable_lambda.cpp
21:48:32 Paul Bibbings@JIJOU
/cygdrive/d/CPPProjects/CLCPPM $
However, I then notice where it says - in =A75.1.2/15:
"It is unspecified whether additional unnamed non-static data
members are declared in the closure type for entities captured
by reference."
To my reading, this appears to introduce an ambiguity over whether the
second example above is valid or not since, where this were to be the
case - that is, where additional non-static data members /are/ declared
for entities captured by reference - it would appear that the assignment
in the function body should fail on the same grounds as for the case of
capture by copy - that it constituted an attempt to assign to a member
of an object of const closure type.
Keep in mind that a reference itself is inherently constant. Once
initialized, it cannot be made to refer to a different object. The
object that is referred to can still be modified even if the reference
is a non-static member and the member function that does so is const:
class foo {
int& ref;
public:
explicit foo(int&r) : ref(r) {}
void blank() const { ref=0; }
// ^^^^^ OK
};
I think the purpose of the text you quoted is simply to allow the
compiler to generate "smaller" closure types. Instead of a reference
member for each function-local variable from the surrounding scope
that is captured by reference, a compiler might include a single
pointer to the "stack frame" and access the objects through this
pointer via fixed offsets. Whether the closure type includes reference
members or just a stack pointer is unspecified. But it doesn't change
the fact that the lambda object's function call operator can modify
variables that have been captured by reference even without the
mutable keyword. Just like pointers, references don't propagate top-
level constness down to the pointee.
Cheers,
SG