Oggetto const copiato in chiusura lambda non mutabile

Question

Sto provando a catturare un oggetto const tramite copia in un lambda (mutabile). Il mio compilatore tuttavia lamenta che l'oggetto catturato è const.

Non dovrebbe essere possibile copiare l'oggetto come non-const?

struct Foo 
{ 
    Foo(){} 
    void Func(){} 
}; 

int main() 
{ 
    const Foo foo; 
    [foo]() mutable { foo.Func(); }; 
} 

compilazione con g ++ 4.7.2:

testcase.cpp: In lambda function: 
testcase.cpp:10:29: error: no matching function for call to ‘Foo::Func() const’ 
testcase.cpp:10:29: note: candidate is: 
testcase.cpp:4:7: note: void Foo::Func() <near match> 
testcase.cpp:4:7: note: no known conversion for implicit ‘this’ parameter from ‘const Foo*’ to ‘Foo*’ 

compilazione con clang ++ 3.1:

testcase.cpp:10:20: error: member function 'Func' not viable: 'this' argument has type 'const Foo', but function is not marked const 
    std::async([foo]() mutable { foo.Func(); }); 

Il documento standard (o meglio il progetto ...) definisce in 5.1.2.14 che "Il tipo [...] è il tipo dell'entità catturata corrispondente", quindi suppongo che includerebbe gli specificatori cv.
Tuttavia non sembra intuitivo.

Answer 1

In primo luogo, il tipo di un'espressione lambda, che ha la cattura, è un tipo di classe (5.1.2 Espressioni lambda [expr.prim.lambda] # 3)

Quel tipo ha un operator(), che è di default const, a meno che mutable sia utilizzato nell'espressione lambda ([expr.prim.lambda] # 5)

Successivamente, per ogni entità acquisita come copia, un membro senza nome viene dichiarato nel tipo di chiusura. [expr.prim.lambda] # 14]

Se si crea in modo esplicito l'equivalente (per lo più) del tipo di acquisizione, tutto seguirà naturalmente dalla consueta semantica per le classi, i tipi qualificati e le funzioni membro qualificato const.

Esempio:

struct S 
{ 
    void f(); 
    void fc() const; 
}; 

void g() 
{ 
    S s0; 

    // [s0]() { s0.f(); }; // error, operator() is const 
    [s0]() { s0.fc(); }; // OK, operator() is const, S::fc is const 

    [s0]() mutable { s0.f(); }; 
    [s0]() mutable { s0.fc(); }; 

    const S s1; 

    // [s1]() { s1.f(); }; // error, s1 is const, no matter if operator() is const 
    [s1]() { s1.fc(); }; 

    // [s1]() mutable { s1.f(); }; // error, s1 is const, no matter if operator() is const 
    [s1]() mutable { s1.fc(); }; 
} 

immagino la confusione deriva dal fatto che mutable nel lambda-dichiaratore riguarda la const -ness del operator(), non il mutable -ility dei membri di dati del tipo di chiusura . Sarebbe più naturale usare const, come con le funzioni dei membri, ma suppongo che il comitato degli standard abbia voluto che const fosse l'impostazione predefinita.

Answer 2

Un'altra soluzione possibile:

struct Foo 
    { 
     Foo(){} 
     void Func(){} 
    }; 

    int main() 
    { 
     const Foo foo; 
     { 
      Foo& fooo= const_cast<Foo&>(foo); 
      [fooo]() mutable { fooo.Func(); }; 
     } 
    } 

Questa soluzione presenta problemi di sicurezza (modifica accidentale dell 'oggetto const facendo riferimento non const è possibile), ma la copia aggiuntiva è evitata.