Tại sao lambda của C ++ 11 lại yêu cầu từ khóa có thể thay đổi được cho tính năng bắt lỗi theo mặc định?

Ví dụ ngắn:

#include <iostream>

int main()
{
    int n;
    [&](){n = 10;}();             // OK
    [=]() mutable {n = 20;}();    // OK
    // [=](){n = 10;}();          // Error: a by-value capture cannot be modified in a non-mutable lambda
    std::cout << n << "\n";       // "10"
}

Câu hỏi: Tại sao chúng ta cần mutabletừ khóa? Nó khá khác với tham số truyền thống truyền đến các hàm được đặt tên. Lý do đằng sau là gì?

Tôi có ấn tượng rằng toàn bộ quan điểm của giá trị nắm bắt là cho phép người dùng thay đổi tạm thời - nếu không thì tôi hầu như luôn luôn tốt hơn khi sử dụng tham chiếu chụp, phải không?

Có giác ngộ nào không?

(Nhân tiện, tôi đang sử dụng MSVC2010. AFAIK đây phải là tiêu chuẩn)

Nó yêu cầu mutablebởi vì theo mặc định, một đối tượng hàm sẽ tạo ra kết quả tương tự mỗi lần nó được gọi. Đây là sự khác biệt giữa một hàm định hướng đối tượng và một hàm sử dụng biến toàn cục, một cách hiệu quả.

Mã của bạn gần như tương đương với điều này:

#include <iostream>

class unnamed1
{
    int& n;
public:
    unnamed1(int& N) : n(N) {}

    /* OK. Your this is const but you don't modify the "n" reference,
    but the value pointed by it. You wouldn't be able to modify a reference
    anyway even if your operator() was mutable. When you assign a reference
    it will always point to the same var.
    */
    void operator()() const {n = 10;}
};

class unnamed2
{
    int n;
public:
    unnamed2(int N) : n(N) {}

    /* OK. Your this pointer is not const (since your operator() is "mutable" instead of const).
    So you can modify the "n" member. */
    void operator()() {n = 20;}
};

class unnamed3
{
    int n;
public:
    unnamed3(int N) : n(N) {}

    /* BAD. Your this is const so you can't modify the "n" member. */
    void operator()() const {n = 10;}
};

int main()
{
    int n;
    unnamed1 u1(n); u1();    // OK
    unnamed2 u2(n); u2();    // OK
    //unnamed3 u3(n); u3();  // Error
    std::cout << n << "\n";  // "10"
}

Vì vậy, bạn có thể nghĩ lambdas như tạo một lớp với toán tử () mặc định là const trừ khi bạn nói rằng nó có thể thay đổi.

Bạn cũng có thể nghĩ về tất cả các biến được nắm bắt bên trong [] (rõ ràng hoặc ngầm) là thành viên của lớp đó: bản sao của các đối tượng cho [=] hoặc tham chiếu đến các đối tượng cho [&]. Chúng được khởi tạo khi bạn khai báo lambda của bạn như thể có một hàm tạo ẩn.

Tôi có ấn tượng rằng toàn bộ quan điểm của giá trị nắm bắt là cho phép người dùng thay đổi tạm thời - nếu không thì tôi hầu như luôn luôn tốt hơn khi sử dụng tham chiếu chụp, phải không?

Câu hỏi là, nó "gần như"? Một trường hợp sử dụng thường xuyên dường như là để trả lại hoặc vượt qua lambdas:

void registerCallback(std::function<void()> f) { /* ... */ }

void doSomething() {
  std::string name = receiveName();
  registerCallback([name]{ /* do something with name */ });
}

Tôi nghĩ đó mutablekhông phải là một trường hợp "gần như". Tôi xem xét "bắt theo giá trị" như "cho phép tôi sử dụng giá trị của nó sau khi thực thể bị bắt chết" thay vì "cho phép tôi thay đổi bản sao của nó". Nhưng có lẽ điều này có thể được tranh luận.

FWIW, Herb Sutter, một thành viên nổi tiếng của ủy ban tiêu chuẩn hóa C ++, cung cấp một câu trả lời khác nhau cho câu hỏi đó trong các vấn đề về tính chính xác và khả năng sử dụng của Lambda :

Hãy xem xét ví dụ người rơm này, nơi lập trình viên nắm bắt một biến cục bộ theo giá trị và cố gắng sửa đổi giá trị đã bắt (là biến thành viên của đối tượng lambda):

int val = 0;
auto x = [=](item e)            // look ma, [=] means explicit copy
            { use(e,++val); };  // error: count is const, need ‘mutable’
auto y = [val](item e)          // darnit, I really can’t get more explicit
            { use(e,++val); };  // same error: count is const, need ‘mutable’

Tính năng này dường như đã được thêm vào do lo ngại rằng người dùng có thể không nhận ra mình đã có một bản sao và đặc biệt là vì lambdas có thể sao chép nên anh ta có thể thay đổi một bản sao khác của lambda.

Bài viết của ông là về lý do tại sao điều này nên được thay đổi trong C ++ 14. Nó ngắn gọn, được viết tốt, đáng đọc nếu bạn muốn biết "những gì trong tâm trí [thành viên ủy ban]" liên quan đến tính năng đặc biệt này.

Bạn cần nghĩ kiểu đóng của hàm Lambda là gì. Mỗi khi bạn khai báo một biểu thức Lambda, trình biên dịch sẽ tạo ra một kiểu đóng, không khác gì một khai báo lớp không tên với các thuộc tính ( môi trường nơi biểu thức Lambda được khai báo) và lệnh gọi hàm được ::operator()thực thi. Khi bạn chụp một biến bằng copy-by-value , trình biên dịch sẽ tạo một constthuộc tính mới trong kiểu đóng, vì vậy bạn không thể thay đổi nó trong biểu thức Lambda vì đó là thuộc tính "chỉ đọc", đó là lý do chúng gọi nó là "bao đóng ", bởi vì theo một cách nào đó, bạn đang đóng biểu thức Lambda của mình bằng cách sao chép các biến từ phạm vi trên vào phạm vi Lambda.mutable, thực thể bị bắt sẽ trở thành một non-constthuộc tính của kiểu đóng của bạn. Đây là nguyên nhân khiến các thay đổi được thực hiện trong biến có thể thay đổi được ghi theo giá trị, không được truyền đến phạm vi trên, nhưng giữ bên trong Lambda có trạng thái. Luôn cố gắng tưởng tượng kiểu đóng kết quả của biểu thức Lambda của bạn, điều đó đã giúp tôi rất nhiều và tôi hy vọng nó cũng có thể giúp bạn.

Xem dự thảo này , theo 5.1.2 [expr.prim.lambda], mục 5:

Kiểu đóng cho biểu thức lambda có toán tử gọi hàm nội tuyến công khai (13,5.4) có tham số và kiểu trả về được mô tả theo mệnh đề tham số-khai báo tham số và biểu thức tương ứng của lambda-biểu thức. Toán tử gọi hàm này được khai báo const (9.3.1) khi và chỉ khi mệnh đề khai báo tham số của lambdaexpression không được theo sau bởi mutable.

Chỉnh sửa nhận xét của litb: Có lẽ họ đã nghĩ đến việc nắm bắt theo giá trị để những thay đổi bên ngoài đối với các biến không được phản ánh bên trong lambda? Tài liệu tham khảo hoạt động cả hai cách, vì vậy đó là lời giải thích của tôi. Không biết nó có tốt không.

Chỉnh sửa trên nhận xét của kizzx2: Hầu hết thời gian sử dụng lambda là functor cho các thuật toán. Tính năng mặc định constcho phép nó được sử dụng trong một môi trường không đổi, giống như các consthàm đủ tiêu chuẩn thông thường có thể được sử dụng ở đó, nhưng các hàm không constđủ tiêu chuẩn thì không thể. Có lẽ họ chỉ nghĩ làm cho nó trực quan hơn cho những trường hợp đó, những người biết những gì diễn ra trong tâm trí họ. :)

Tôi có ấn tượng rằng toàn bộ quan điểm của giá trị nắm bắt là cho phép người dùng thay đổi tạm thời - nếu không thì tôi hầu như luôn luôn tốt hơn khi sử dụng tham chiếu chụp, phải không?

nlà không tạm thời. n là thành viên của lambda-function-object mà bạn tạo bằng biểu thức lambda. Kỳ vọng mặc định là việc gọi lambda của bạn không sửa đổi trạng thái của nó, do đó, nó là để ngăn bạn vô tình sửa đổi n.

Bạn phải hiểu ý nghĩa của việc chụp! nó đang nắm bắt không tranh luận đi qua! Hãy xem một số mẫu mã:

int main()
{
    using namespace std;
    int x = 5;
    int y;
    auto lamb = [x]() {return x + 5; };

    y= lamb();
    cout << y<<","<< x << endl; //outputs 10,5
    x = 20;
    y = lamb();
    cout << y << "," << x << endl; //output 10,20

}

Như bạn có thể thấy mặc dù xđã được đổi thành 20lambda vẫn trả về 10 ( xvẫn 5ở bên trong lambda) Thay đổi xbên trong lambda có nghĩa là thay đổi chính lambda ở mỗi cuộc gọi (lambda đang biến đổi trong mỗi cuộc gọi). Để thực thi tính đúng đắn, tiêu chuẩn đã đưa ra mutabletừ khóa. Bằng cách chỉ định lambda là có thể thay đổi, bạn đang nói rằng mỗi cuộc gọi đến lambda có thể gây ra thay đổi trong chính lambda. Hãy xem một ví dụ khác:

int main()
{
    using namespace std;
    int x = 5;
    int y;
    auto lamb = [x]() mutable {return x++ + 5; };

    y= lamb();
    cout << y<<","<< x << endl; //outputs 10,5
    x = 20;
    y = lamb();
    cout << y << "," << x << endl; //outputs 11,20

}

Ví dụ trên cho thấy rằng bằng cách làm cho lambda có thể thay đổi, việc thay đổi xbên trong lambda "biến đổi" lambda ở mỗi cuộc gọi với một giá trị mới xkhông liên quan gì đến giá trị thực của xhàm chính

Hiện tại có một đề xuất để giảm bớt sự cần thiết mutabletrong các tuyên bố lambda: n3424

Để mở rộng câu trả lời của Puppy, các hàm lambda được dự định là các hàm thuần túy . Điều đó có nghĩa là mỗi cuộc gọi được cung cấp một bộ đầu vào duy nhất luôn trả về cùng một đầu ra. Hãy xác định đầu vào là tập hợp của tất cả các đối số cộng với tất cả các biến được bắt khi lambda được gọi.

Trong các hàm thuần túy đầu ra chỉ phụ thuộc vào đầu vào chứ không phụ thuộc vào một số trạng thái bên trong. Do đó, bất kỳ chức năng lambda nào, nếu thuần túy, không cần thay đổi trạng thái của nó và do đó là bất biến.

Khi lambda nắm bắt bằng cách tham chiếu, viết vào các biến bị bắt là một biến dạng đối với khái niệm hàm thuần túy, bởi vì tất cả một hàm thuần nên làm là trả về một đầu ra, mặc dù lambda không chắc chắn bị đột biến vì việc viết xảy ra với các biến ngoài. Ngay cả trong trường hợp này, một cách sử dụng đúng ngụ ý rằng nếu lambda được gọi lại với cùng một đầu vào, thì đầu ra sẽ giống nhau mọi lúc, mặc dù các tác dụng phụ này đối với các biến phụ. Các tác dụng phụ như vậy chỉ là cách để trả về một số đầu vào bổ sung (ví dụ: cập nhật bộ đếm) và có thể được định dạng lại thành một hàm thuần túy, ví dụ trả về một tuple thay vì một giá trị.