Mengapa tidak ada konstruksi 'akhirnya' di C ++?

Penanganan pengecualian di C ++ terbatas untuk mencoba / melempar / menangkap. Tidak seperti Object Pascal, Java, C # dan Python, bahkan dalam C ++ 11, finallykonstruksinya belum diimplementasikan.

Saya telah melihat banyak sekali literatur C ++ yang membahas "pengecualian kode aman". Lippman menulis bahwa pengecualian kode aman adalah topik yang penting namun canggih, sulit, di luar cakupan Primer-nya - yang tampaknya menyiratkan bahwa kode aman tidak mendasar bagi C ++. Herb Sutter menyediakan 10 bab untuk topik ini dalam C ++ Luar Biasa!

Namun bagi saya tampaknya banyak masalah yang dihadapi ketika mencoba untuk menulis "pengecualian kode aman" dapat diselesaikan dengan baik jika finallykonstruksinya diimplementasikan, yang memungkinkan programmer untuk memastikan bahwa bahkan jika ada pengecualian, program dapat dipulihkan. ke keadaan aman, stabil, bebas kebocoran, dekat dengan titik alokasi sumber daya dan kode berpotensi bermasalah. Sebagai programmer Delphi dan C # yang sangat berpengalaman saya menggunakan try .. akhirnya memblokir kode saya secara ekstensif, seperti halnya kebanyakan programmer dalam bahasa ini.

Mempertimbangkan semua 'lonceng dan peluit' yang diimplementasikan dalam C ++ 11, saya terkejut menemukan bahwa 'akhirnya' masih belum ada.

Jadi, mengapa finallykonstruksinya tidak pernah diimplementasikan dalam C ++? Ini benar-benar bukan konsep yang sangat sulit atau lanjutan untuk dipahami dan berjalan jauh ke arah membantu programmer untuk menulis 'pengecualian kode aman'.

Seperti beberapa komentar tambahan pada jawaban @ Nemanja (yang, karena mengutip Stroustrup, benar-benar sama baiknya dengan jawaban yang Anda dapatkan):

Ini benar-benar hanya masalah memahami filosofi dan idiom C ++. Ambil contoh operasi yang membuka koneksi database pada kelas persisten dan harus memastikan bahwa itu menutup koneksi jika pengecualian dilemparkan. Ini adalah masalah keamanan pengecualian dan berlaku untuk bahasa apa pun dengan pengecualian (C ++, C #, Delphi ...).

Dalam bahasa yang menggunakan try/ finally, kode tersebut mungkin terlihat seperti ini:

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

Sederhana dan mudah. Namun, ada beberapa kelemahan:

• Jika bahasa tidak memiliki destruktor deterministik, saya selalu harus menulis finallyblok, kalau tidak saya membocorkan sumber daya.
• Jika DoRiskyOperationlebih dari satu pemanggilan metode tunggal - jika saya memiliki beberapa pemrosesan yang harus dilakukan di tryblok - maka Closeoperasi dapat berakhir menjadi agak jauh dari Openoperasi. Saya tidak bisa menulis pembersihan di sebelah akuisisi saya.
• Jika saya memiliki beberapa sumber daya yang perlu diperoleh kemudian dibebaskan dengan cara pengecualian-aman, saya bisa berakhir dengan beberapa lapisan dalam try/ finallyblok.

Pendekatan C ++ akan terlihat seperti ini:

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

Ini sepenuhnya menyelesaikan semua kelemahan dari finallypendekatan. Ini memiliki beberapa kelemahan sendiri, tetapi mereka relatif kecil:

• Ada peluang bagus Anda harus menulis ScopedDatabaseConnectionsendiri kelas itu. Namun, ini adalah implementasi yang sangat sederhana - hanya 4 atau 5 baris kode.
• Ini melibatkan pembuatan variabel lokal ekstra - yang Anda tampaknya bukan penggemar, berdasarkan komentar Anda tentang "terus-menerus membuat dan menghancurkan kelas untuk bergantung pada destruktor mereka untuk membersihkan kekacauan Anda sangat buruk" - tetapi kompiler yang baik akan mengoptimalkan keluar dari pekerjaan ekstra yang melibatkan variabel lokal tambahan. Desain C ++ yang baik sangat bergantung pada optimasi semacam ini.

Secara pribadi, mengingat kelebihan dan kekurangan ini, saya menemukan teknik RAII yang lebih disukai finally. Jarak tempuh Anda mungkin beragam.

Akhirnya, karena RAII adalah idiom mapan dalam C ++, dan untuk meringankan pengembang dari beberapa beban menulis banyak Scoped...kelas, ada perpustakaan seperti ScopeGuard dan Boost.ScopeExit yang memfasilitasi semacam pembersihan deterministik ini.

Dari Mengapa C ++ tidak menyediakan konstruksi "akhirnya"? di FAQ Gaya dan Teknik C ++ Bjarne Stroustrup :

Karena C ++ mendukung alternatif yang hampir selalu lebih baik: Teknik "akuisisi sumber daya adalah inisialisasi" (TC ++ PL3 bagian 14.4). Ide dasarnya adalah untuk mewakili sumber daya oleh objek lokal, sehingga destruktor objek lokal akan melepaskan sumber daya. Dengan begitu, programmer tidak bisa melupakan untuk merilis resource.

Alasan yang tidak dimiliki C ++ finallyadalah karena tidak diperlukan dalam C ++. finallydigunakan untuk mengeksekusi beberapa kode terlepas dari apakah pengecualian telah terjadi atau tidak, yang hampir selalu merupakan semacam kode pembersihan. Dalam C ++, kode pembersihan ini harus dalam destruktor dari kelas yang relevan dan destruktor akan selalu dipanggil, seperti halnya sebuah finallyblok. Ungkapan menggunakan destructor untuk pembersihan Anda disebut RAII .

Di dalam komunitas C ++ mungkin ada lebih banyak pembicaraan tentang kode 'pengecualian aman', tetapi hampir sama pentingnya dalam bahasa lain yang memiliki pengecualian. Inti dari kode 'pengecualian aman' adalah bahwa Anda memikirkan dalam keadaan apa kode Anda dibiarkan jika pengecualian terjadi di salah satu fungsi / metode yang Anda panggil.
Dalam C ++, kode 'exception safe' sedikit lebih penting, karena C ++ tidak memiliki pengumpulan sampah otomatis yang menangani objek yang ditinggalkan yatim karena pengecualian.

Alasan keamanan pengecualian lebih banyak dibahas di komunitas C ++ mungkin juga berasal dari kenyataan bahwa di C ++ Anda harus lebih waspada terhadap apa yang bisa salah, karena ada lebih sedikit jaring pengaman default dalam bahasa tersebut.

Yang lain telah membahas RAII sebagai solusinya. Ini solusi yang sangat bagus. Tetapi itu tidak benar-benar membahas mengapa mereka tidak menambahkan finallyjuga karena itu adalah hal yang diinginkan secara luas. Jawabannya lebih mendasar pada desain dan pengembangan C ++: selama pengembangan C ++ mereka yang terlibat telah sangat menentang pengenalan fitur desain yang dapat dicapai dengan menggunakan fitur lain tanpa banyak keributan dan terutama di mana ini membutuhkan pengenalan kata kunci baru yang dapat membuat kode lama tidak kompatibel. Karena RAII menyediakan alternatif yang sangat fungsional finallydan Anda sebenarnya dapat memutar sendiri finallydi C ++ 11, ada sedikit panggilan untuk itu.

Yang perlu Anda lakukan adalah membuat kelas Finallyyang memanggil fungsi yang diteruskan ke konstruktor di destruktor itu. Maka Anda dapat melakukan ini:

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

    database.doRisky();
}

Kebanyakan programmer C ++ asli, secara umum, lebih suka objek RAII yang dirancang dengan rapi.

Anda dapat menggunakan pola "perangkap" - bahkan jika Anda tidak ingin menggunakan blok coba / tangkap.

Letakkan objek sederhana dalam cakupan yang diperlukan. Dalam destruktor objek ini masukkan logika "akhirnya" Anda. Tidak peduli apa, ketika tumpukan dibatalkan, destruktor objek akan dipanggil dan Anda akan mendapatkan permen Anda.

Nah, Anda bisa mengurutkan roll Anda sendiri finally, menggunakan Lambdas, yang akan mendapatkan yang berikut untuk dikompilasi dengan baik (menggunakan contoh tanpa RAII tentu saja, bukan potongan kode terbaik):

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

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

Lihat artikel ini .

Saya tidak yakin saya setuju dengan pernyataan di sini bahwa RAII adalah superset dari finally. Tumit achilles dari RAII sederhana: pengecualian. RAII diimplementasikan dengan destruktor, dan selalu salah dalam C ++ untuk membuang destruktor. Itu berarti bahwa Anda tidak dapat menggunakan RAII ketika Anda perlu membuang kode pembersihan Anda. Jika finallyditerapkan, di sisi lain, tidak ada alasan untuk percaya bahwa itu tidak sah untuk dilempar dari finallyblok.

Pertimbangkan jalur kode seperti ini:

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

Jika kita punya finallykita bisa menulis:

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

Tapi tidak ada cara, yang bisa saya temukan, untuk mendapatkan perilaku yang setara menggunakan RAII.

Jika seseorang tahu bagaimana melakukan ini di C ++, saya sangat tertarik dengan jawabannya. Saya bahkan akan senang dengan sesuatu yang mengandalkan, misalnya, menegakkan bahwa semua pengecualian diwarisi dari satu kelas dengan beberapa kemampuan khusus atau sesuatu.