Đối tượng const đã sao chép trong kết cấu lambda không thể thay đổi được

Question

Tôi đang cố chụp một đối tượng const qua bản sao trong lambda (có thể thay đổi). Trình biên dịch của tôi tuy nhiên phàn nàn, rằng đối tượng đã capture là const.

Nếu không thể sao chép đối tượng dưới dạng không const thì không thể?

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

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

Biên soạn với 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*’ 

Biên soạn với kêu vang ++ 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(); }); 

Tài liệu chuẩn (hay đúng hơn là dự thảo ...) định nghĩa trong 5.1.2.14 rằng "Kiểu [...] là kiểu của thực thể được capture tương ứng", vì vậy tôi đoán rằng nó sẽ bao gồm các cv-specifiers.
Mặc dù nó không có vẻ trực quan.

Answer 1

Thứ nhất, các loại của một biểu thức lambda, trong đó có chụp, là một loại lớp (5.1.2 biểu thức Lambda [expr.prim.lambda] # 3)

loại đó có một operator() mà là theo mặc định const, trừ khi mutable được sử dụng trong biểu thức lambda ([expr.prim.lambda] # 5)

Tiếp theo, đối với mỗi thực thể được chụp dưới dạng bản sao, một thành viên chưa được đặt tên được khai báo trong loại đóng. [expr.prim.lambda] # 14]

Nếu bạn xây dựng một cách rõ ràng (chủ yếu) tương đương với loại chụp, mọi thứ sẽ tự nhiên theo từ ngữ nghĩa thông thường cho các lớp, các loại đủ điều kiện const và hàm thành viên đủ điều kiện.

Ví dụ:

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(); }; 
} 

Tôi đoán sự nhầm lẫn bắt nguồn từ thực tế là mutable trong lambda-declarator liên quan đến const -ness của operator(), không phải là mutable -ility của các thành viên dữ liệu của các loại đóng cửa . Sẽ là tự nhiên khi sử dụng const, như với các hàm thành viên, nhưng tôi đoán ủy ban tiêu chuẩn muốn const làm mặc định.

Answer 2

Một workaround thể:

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

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

Giải pháp này có vấn đề về an toàn (sửa đổi ngẫu nhiên của đối tượng const thông qua tham chiếu không const có thể), nhưng sao chép thêm được tránh.