Lambda: Tại sao giá trị được ghi lại bởi giá trị const, nhưng giá trị theo từng tham chiếu không?

Question

Sao chụp-by-value giá trị const, nhưng bị bắt-by-reference đối tượng không được phép:

int a; 

auto compile_error = [=]() 
{ 
    a = 1; 
} 
auto compiles_ok = [&]() 
{ 
    a = 1; 
} 

Đối với tôi này dường như vô lý nhưng nó dường như là tiêu chuẩn? Đặc biệt là sự sửa đổi không mong muốn của một giá trị bắt được có thể là một lỗi gây phiền nhiễu, nhưng rất có thể là hậu quả bị giới hạn trong phạm vi lambda, trong khi việc sửa đổi không mong muốn đối tượng bị bắt bằng tham chiếu sẽ dẫn đến các hiệu ứng nghiêm trọng hơn.

Vậy tại sao không chụp bằng tham chiếu const cho mỗi mặc định? Hoặc ít nhất hỗ trợ [const &] và [&]? Lý do cho thiết kế này là gì?

Vì cách giải quyết khác, bạn có thể phải sử dụng tham chiếu std :: cref được bao bọc bởi giá trị?

Answer 1

Tham chiếu được chụp là cũng const. Hay đúng hơn, tham chiếu là luôn là hoàn toàn const - không có cú pháp nào trong ngôn ngữ cho phép bạn thay đổi nơi tham chiếu trỏ đến. a = 1; khi a là tham chiếu không thay đổi tham chiếu, nhưng thay đổi điều tham chiếu tham chiếu.

Khi bạn nói về "tham chiếu const", tôi nghĩ bạn đang bối rối. Bạn đang nói về "tham chiếu đến const int" (const int &). "Const" có đề cập đến điểm mà tham chiếu trỏ tới, không phải là tham chiếu. Nó tương tự với con trỏ: với "con trỏ đến const int" (const int *), con trỏ chính nó không phải là const - bạn có thể gán cho một biến loại này tất cả các bạn muốn. Một "con trỏ const" thực sẽ là int *const. Ở đây, bạn không thể gán cho một cái gì đó thuộc loại này; nhưng bạn có thể sửa đổi int nó trỏ đến. Do đó, "const" cho con trỏ hoặc tham chiếu tách biệt với "const" cho điều nó trỏ tới. Bạn cũng có thể có "const pointer to const int": const int *const.

Answer 2

Logic của tôi nói như sau: lambdas chỉ là một đoạn mã, với các tham chiếu cần thiết tùy chọn. Trong trường hợp bạn cần thực sự sao chép một cái gì đó (thường xảy ra cho mục đích quản lý bộ nhớ, chẳng hạn như sao chép shared_ptr), bạn vẫn không thực sự muốn lambda có trạng thái riêng của nó. Đó là một tình huống khá bất thường.

Tôi nghĩ rằng chỉ có 2 lựa chọn sau đây cảm thấy "đúng"

• Kèm theo một số mã sử dụng một số các biến địa phương, do đó bạn có thể "vượt qua nó xung quanh"
• Giống như trên, chỉ thêm quản lý bộ nhớ , bởi vì có thể bạn muốn thực thi đoạn mã đó một cách không đồng bộ hoặc một cái gì đó và phạm vi tạo sẽ biến mất.

Nhưng khi một lambda là "có thể thay đổi", nghĩa là, nó chụp các giá trị mà không const, điều này có nghĩa rằng nó thực sự hỗ trợ của chính mình bang. Có nghĩa là, mỗi khi bạn gọi số lambda, nó có thể mang lại kết quả khác, không dựa trên đóng cửa thực tế, nhưng một lần nữa, trên trạng thái nội bộ nội bộ của chúng tôi. , xem xét rằng lambdas có nguồn gốc từ các ngôn ngữ chức năng.Tuy nhiên, C++, là C++, cung cấp cho bạn một cách để vượt qua giới hạn đó, bằng cách làm cho nó xấu xí hơn một chút, chỉ để đảm bảo rằng bạn nhận thức được thực tế rằng bạn đang làm điều gì đó lạ lùng.

Tôi hy vọng lý do này với bạn.

Answer 3

Giả sử bạn đang chụp con trỏ theo giá trị. Con trỏ chính nó là const, nhưng truy cập vào đối tượng mà nó trỏ đến không phải là.

int i = 0; 
int* p = &i; 
auto l = [=]{ ++*p; }; 
l(); 
std::cout << i << std::endl; // outputs 1 

lambda này tương đương với:

struct lambda { 
    int* p; 
    lambda(int* p_) : p(p_) {} 
    void operator()() const { ++*p; } 
}; 

Các const trên operator()() làm cho việc sử dụng của p tương đương với tuyên bố nó như là:

int* const p; 

điều tương tự sẽ xảy ra với một tham chiếu. Tham chiếu chính nó là "const" (trong dấu ngoặc kép bởi vì tham chiếu không thể được reseated), nhưng truy cập vào đối tượng nó đề cập đến là không.