gọi đệ quy trong lambda (C++ 11)

Question

thể trùng lặp:
Recursive lambda functions in c++0x

Tại sao tôi không thể gọi một lambda đệ quy nếu tôi viết nó như:

auto a = [&] 
{ 
    static int i = 0; i++; 
    std::cout << i << std::endl; 
    if (i<10) 
    a(); //recursive call 
}; 

Nó cung cấp lỗi biên dịch (ideone):

prog.cpp:8:18: error: '((const main()::<lambda()>*)this)->main()::<lambda()>::a' cannot be used as a function 

prog.cpp: In function 'int main()': 
prog.cpp:9:9: error: variable 'auto a' with 'auto' type used in its own initializer 

Lỗi này có nghĩa là gì?

tôi hiểu được lý do tại sao tôi không thể viết này:

auto i=i+1; //error: unable to deduce 'auto' from '<expression error>' 

Chúng ta không thể viết những dòng này vì kiểu i phải được rút ra từ đó là khởi tạo, có nghĩa là loại không thể được suy luận nếu i chính nó xuất hiện trong khởi tạo (ideone). Nhưng làm thế nào nó quan trọng trong trường hợp lambda? Nếu tôi không sai, kiểu lambda được xác định bởi tham số của nó và kiểu trả về; nó không phụ thuộc vào cơ thể nếu nó không trả về gì (trong trường hợp này, kiểu trả về được suy ra là void, bất kể các câu lệnh khác trong thân lambda).

Dù sao, tôi có một cách giải quyết, và tôi có thể sử dụng thay vì std::function như:

std::function<void()> a = [&] 
{ 
    static int i = 0; i++; 
    std::cout << i << std::endl; 
    if (i<10) 
     a(); 
}; 

mà biên dịch tiền phạt (ideone). Nhưng tôi vẫn muốn biết lý do tại sao phiên bản auto không biên dịch.

Answer 1

Lý do là không có trường hợp đặc biệt nào cho trình khởi tạo biểu thức lambda của các biến số auto.

Trường hợp đặc biệt như vậy sẽ dễ bị lỗi và lạm dụng. Bạn cần phải xác định các quy tắc khi bạn đề xuất rằng một cái gì đó như a() sẽ hoạt động. Làm thế nào là operator() tra cứu? Trạng thái chính xác của loại a là gì? Loại sẽ hoàn thành? (có nghĩa là bạn đã biết danh sách chụp của lambda). Một khi bạn đã xây dựng rằng trong một định dạng hợp lý cho một spec, nó sẽ được dễ dàng hơn để làm cho báo cáo về nó.

Cho phép trường hợp sử dụng của bạn sẽ có nghĩa là thêm một trường hợp bạn cần phải quét trước trong mã, vì để xác định loại của a trong a() bạn phải chắc chắn rằng initializer kết thúc mà không có gì có thể "unlambda" kiểu

struct y { void operator()() { } }; 
template<typename T> y operator+(T, y) { return y(); } 
auto x = [] { x(); } + y(); 

Trong trường hợp này, x() sẽ gọi y::operator(), không gọi là lambda.

Vì hiện tại, a chỉ bị cấm được đề cập trong toàn bộ trình khởi tạo của nó. Bởi vì trong C++, auto là không phải là một loại. Nó chỉ đơn thuần là kiểu số chỉ định đứng cho loại được suy ra. Kết quả là, một biểu thức không bao giờ có thể nhập tự động.

Answer 2

Như tôi thấy sự khác biệt quan trọng giữa trường hợp auto a và trường hợp std::function<void()> a là loại std::function<void()> không biết/quan tâm đến loại chức năng thực mà nó đề cập đến thực sự là gì. Viết:

std::function<void()> a; 

là hoàn toàn tốt đẹp, nơi như:

auto a; 

không khôn ngoan. Vì vậy, khi thời gian đến để tổng hợp việc chụp nếu bạn sử dụng std::function<void()> tất cả những gì cần biết về loại đã được biết, trong khi với auto nó vẫn chưa được biết.

Answer 3

Trong một hàm đệ quy f được xác định bởi f và kiểu trả về của f cũng được xác định bởi f trong trường hợp auto nên nó dẫn đến đệ quy vô hạn.

khi auto cố gắng lấy được loại. decltype (f()) sẽ tiếp tục suy ra một decltype khác (f) `như f có nguồn gốc từ f, ví dụ một cuộc gọi trên bất kỳ đệ quy nào cũng đệ quy. xác định kiểu trả về sẽ chuyển thành đệ quy khi được áp dụng trên hàm đệ quy. trong một hàm đệ quy kết thúc đệ quy có thể được thực hiện trong thời gian chạy. nhưng xác định là tĩnh chỉ