Tại sao không có cấu trúc 'cuối cùng' trong C ++?

Xử lý ngoại lệ trong C ++ bị giới hạn ở thử / ném / bắt. Không giống như Object Pascal, Java, C # và Python, ngay cả trong C ++ 11, finallycấu trúc đã không được thực hiện.

Tôi đã thấy rất nhiều tài liệu C ++ bàn về "mã an toàn ngoại lệ". Lippman viết rằng mã an toàn ngoại lệ là một chủ đề quan trọng nhưng tiên tiến, khó, vượt ra ngoài phạm vi của Primer của anh ta - điều này dường như ngụ ý rằng mã an toàn không phải là nền tảng của C ++. Herb Sutter dành 10 chương cho chủ đề trong C ++ đặc biệt của mình!

Tuy nhiên, dường như nhiều vấn đề gặp phải khi cố gắng viết "mã an toàn ngoại lệ" có thể được giải quyết khá tốt nếu finallycấu trúc được triển khai, cho phép lập trình viên đảm bảo rằng ngay cả trong trường hợp ngoại lệ, chương trình có thể được khôi phục đến trạng thái an toàn, ổn định, không rò rỉ, gần với điểm phân bổ tài nguyên và mã có khả năng có vấn đề. Là một lập trình viên Delphi và C # rất có kinh nghiệm, tôi sử dụng thử .. cuối cùng cũng chặn khá nhiều mã của tôi, cũng như hầu hết các lập trình viên trong các ngôn ngữ này.

Xem xét tất cả các 'chuông và còi' được triển khai trong C ++ 11, tôi đã rất ngạc nhiên khi thấy rằng 'cuối cùng' vẫn không có ở đó.

Vậy, tại sao finallycấu trúc chưa bao giờ được thực hiện trong C ++? Đây thực sự không phải là một khái niệm quá khó hoặc tiên tiến để nắm bắt và đi một chặng đường dài hướng tới việc giúp lập trình viên viết 'mã an toàn ngoại lệ'.

Như một số bình luận bổ sung về câu trả lời của @ Nemanja (trong đó, vì nó trích dẫn Stroustrup, thực sự là một câu trả lời tốt như bạn có thể nhận được):

Đó thực sự chỉ là vấn đề hiểu triết lý và thành ngữ của C ++. Lấy ví dụ của bạn về một hoạt động mở kết nối cơ sở dữ liệu trên một lớp liên tục và phải đảm bảo rằng nó đóng kết nối đó nếu ném ngoại lệ. Đây là vấn đề an toàn ngoại lệ và áp dụng cho bất kỳ ngôn ngữ nào có ngoại lệ (C ++, C #, Delphi ...).

Trong ngôn ngữ sử dụng try/ finally, mã có thể trông giống như thế này:

database.Open();
try {
    database.DoRiskyOperation();
} finally {
    database.Close();
}

Đơn giản và dễ hiểu. Tuy nhiên, có một vài nhược điểm:

• Nếu ngôn ngữ không có hàm hủy xác định, tôi luôn phải viết finallykhối, nếu không tôi sẽ rò rỉ tài nguyên.
• Nếu DoRiskyOperationnhiều hơn một cuộc gọi phương thức duy nhất - nếu tôi có một số xử lý phải thực hiện trong trykhối - thì Closehoạt động có thể kết thúc cách xa Openhoạt động một chút . Tôi không thể viết dọn dẹp của tôi ngay bên cạnh việc mua lại của tôi.
• Nếu tôi có một số tài nguyên cần phải mua thì được giải phóng theo cách an toàn ngoại lệ, tôi có thể kết thúc với một vài lớp sâu try/ finallykhối.

Cách tiếp cận C ++ sẽ như thế này:

ScopedDatabaseConnection scoped_connection(database);
database.DoRiskyOperation();

Điều này hoàn toàn giải quyết tất cả các nhược điểm của finallyphương pháp này. Nó có một vài nhược điểm của riêng nó, nhưng chúng tương đối nhỏ:

• Có một cơ hội tốt bạn cần phải tự viết ScopedDatabaseConnectionlớp. Tuy nhiên, đó là một cách thực hiện rất đơn giản - chỉ có 4 hoặc 5 dòng mã.
• Nó liên quan đến việc tạo thêm một biến cục bộ - mà bạn dường như không phải là người hâm mộ, dựa trên nhận xét của bạn về việc "liên tục tạo và hủy các lớp để dựa vào các hàm hủy của chúng để dọn dẹp mớ hỗn độn của bạn là rất kém" - nhưng một trình biên dịch tốt sẽ tối ưu hóa ra bất kỳ công việc bổ sung nào mà một biến cục bộ phụ liên quan. Thiết kế C ++ tốt phụ thuộc rất nhiều vào các loại tối ưu hóa này.

Cá nhân, xem xét những lợi thế và bất lợi này, tôi thấy RAII là một kỹ thuật thích hợp hơn nhiều finally. Số dặm của bạn có thể thay đổi.

Cuối cùng, vì RAII là một thành ngữ được thiết lập tốt trong C ++ và để giảm bớt các nhà phát triển về một số gánh nặng của việc viết nhiều Scoped...lớp, có các thư viện như ScopeGuard và Boost.ScopeExit tạo điều kiện cho việc dọn dẹp xác định này.

Từ Tại sao C ++ không cung cấp cấu trúc "cuối cùng"? trong Câu hỏi thường gặp về Phong cách và Kỹ thuật C ++ của Bjarne Stroustrup :

Bởi vì C ++ hỗ trợ một giải pháp thay thế gần như luôn luôn tốt hơn: Kỹ thuật "thu nhận tài nguyên là khởi tạo" (TC ++ PL3 phần 14.4). Ý tưởng cơ bản là biểu diễn một tài nguyên bởi một đối tượng cục bộ, để hàm hủy của đối tượng cục bộ sẽ giải phóng tài nguyên. Bằng cách đó, lập trình viên không thể quên giải phóng tài nguyên.

Lý do mà C ++ không có finallylà vì nó không cần thiết trong C ++. finallyđược sử dụng để thực thi một số mã bất kể có xảy ra ngoại lệ hay không, mà hầu như luôn luôn là một loại mã dọn dẹp. Trong C ++, mã dọn dẹp này phải nằm trong hàm hủy của lớp có liên quan và hàm hủy sẽ luôn được gọi, giống như một finallykhối. Thành ngữ của việc sử dụng hàm hủy để dọn dẹp của bạn được gọi là RAII .

Trong cộng đồng C ++, có thể nói nhiều hơn về mã 'ngoại lệ an toàn', nhưng nó hầu như không kém phần quan trọng trong các ngôn ngữ khác có ngoại lệ. Toàn bộ điểm của mã 'ngoại lệ an toàn' là bạn nghĩ về trạng thái mà mã của bạn bị bỏ lại nếu một ngoại lệ xảy ra trong bất kỳ chức năng / phương thức nào bạn gọi.
Trong C ++, mã 'ngoại lệ an toàn' quan trọng hơn một chút, vì C ++ không có bộ sưu tập rác tự động chăm sóc các đối tượng bị bỏ rơi mồ côi do một ngoại lệ.

Lý do an toàn ngoại lệ được thảo luận nhiều hơn trong cộng đồng C ++ có lẽ cũng xuất phát từ thực tế là trong C ++, bạn phải nhận thức rõ hơn về những gì có thể sai, bởi vì ngôn ngữ có ít mạng lưới an toàn mặc định hơn.

Những người khác đã thảo luận về RAII là giải pháp. Đó là một giải pháp hoàn toàn tốt. Nhưng điều đó không thực sự giải quyết tại sao họ không thêm finallyvào vì đó là điều mong muốn rộng rãi. Câu trả lời cho điều đó là cơ bản hơn cho thiết kế và phát triển C ++: trong suốt quá trình phát triển C ++, những người liên quan đã phản đối mạnh mẽ việc giới thiệu các tính năng thiết kế có thể đạt được bằng cách sử dụng các tính năng khác mà không cần nhiều sự ồn ào và đặc biệt là điều này đòi hỏi phải giới thiệu từ khóa mới có thể khiến mã cũ không tương thích. Vì RAII cung cấp một giải pháp thay thế có chức năng cao finallyvà bạn thực sự có thể tự quay finallytrong C ++ 11, nên có rất ít lời kêu gọi.

Tất cả những gì bạn cần làm là tạo một lớp Finallygọi hàm được truyền cho hàm tạo của nó trong hàm hủy của nó. Sau đó, bạn có thể làm điều này:

try
{
    Finally atEnd([&] () { database.close(); });

    database.doRisky();
}

Tuy nhiên, hầu hết các lập trình viên C ++ bản địa sẽ thích các đối tượng RAII được thiết kế sạch sẽ.

Bạn có thể sử dụng mẫu "bẫy" - ngay cả khi bạn không muốn sử dụng khối thử / bắt.

Đặt một đối tượng đơn giản trong phạm vi yêu cầu. Trong hàm hủy của đối tượng này đặt logic "cuối cùng" của bạn. Dù thế nào đi chăng nữa, khi ngăn xếp không được giải quyết, kẻ hủy diệt đối tượng sẽ được gọi và bạn sẽ nhận được kẹo của mình.

Chà, bạn có thể sắp xếp cuộn của riêng mình finally, sử dụng Lambdas, cái mà sẽ có được những thứ sau đây để biên dịch tốt (dĩ nhiên sử dụng một ví dụ không có RAII, không phải là đoạn mã đẹp nhất):

{
    FILE *file = fopen("test","w");

    finally close_the_file([&]{
        cout << "We're closing the file in a pseudo-finally clause." << endl;
        fclose(file);
    });
}

Xem bài viết này .

Tôi không chắc chắn tôi đồng ý với các xác nhận ở đây rằng RAII là một siêu thay thế finally. Gót chân achilles của RAII rất đơn giản: ngoại lệ. RAII được triển khai với các hàm hủy và C ++ luôn luôn sai khi loại bỏ hàm hủy. Điều đó có nghĩa là bạn không thể sử dụng RAII khi bạn cần mã dọn dẹp. Nếu finallyđược thực hiện, mặt khác, không có lý do gì để tin rằng việc ném từ một finallykhối sẽ không hợp pháp .

Hãy xem xét một đường dẫn mã như thế này:

void foo() {
    try {
        ... stuff ...
        complex_cleanup();
    } catch (A& a) {
        handle_a(a);
        complex_cleanup();
        throw;
    } catch (B& b) {
        handle_b(b);
        complex_cleanup();
        throw;
    } catch (...) {
        handle_generic();
        complex_cleanup();
        throw;
    }
}

Nếu chúng ta có finallychúng ta có thể viết:

void foo() {
    try {
        ... stuff ...
    } catch (A& a) {
        handle_a(a);
        throw;
    } catch (B& b) {
        handle_b(b);
        throw;
    } catch (...) {
        handle_generic();
        throw;
    } finally {
        complex_cleanup();
    }
}

Nhưng không có cách nào, mà tôi có thể tìm thấy, để có được hành vi tương đương bằng RAII.

Nếu ai đó biết cách làm điều này trong C ++, tôi rất thích câu trả lời. Tôi thậm chí còn hài lòng với một cái gì đó dựa vào, ví dụ, thực thi rằng tất cả các ngoại lệ được thừa hưởng từ một lớp duy nhất với một số khả năng đặc biệt hoặc một cái gì đó.