Idiom C ++ manakah yang tidak digunakan lagi dalam C ++ 11?

Dengan standar baru, ada cara-cara baru dalam melakukan sesuatu, dan banyak yang lebih baik daripada cara-cara lama, tetapi cara lama masih baik-baik saja. Juga jelas bahwa standar baru tidak secara resmi mencela, karena alasan kompatibilitas. Jadi pertanyaan yang tersisa adalah:

Apa cara pengkodean lama yang jelas lebih rendah dari gaya C ++ 11, dan apa yang bisa kita lakukan sekarang?

Dalam menjawab ini, Anda dapat melewati hal-hal yang jelas seperti "gunakan variabel otomatis".

1. Kelas Final : C ++ 11 menyediakan finalspecifier untuk mencegah penurunan kelas
2. C ++ 11 lambdas secara substansial mengurangi kebutuhan akan kelas function object (functor) bernama.
3. Move Constructor : Cara magis di mana std::auto_ptrpekerjaan tidak lagi diperlukan karena dukungan kelas satu untuk referensi nilai.
4. Safe bool : Ini disebutkan sebelumnya. Operator eksplisit C ++ 11 meniadakan idiom C ++ 03 yang sangat umum ini.
5. Shrink-to-fit : Banyak wadah C ++ 11 STL menyediakan ashrink_to_fit() fungsi anggota, yang seharusnya menghilangkan kebutuhan pertukaran dengan sementara.
6. Temporary Base Class : Beberapa pustaka C ++ lama menggunakan idiom yang agak rumit ini. Dengan memindahkan semantik tidak lagi diperlukan.
7. Ketik Enum Enumerasi Aman di C ++ 11.
8. Melarang alokasi heap : = deleteSintaksnya adalah cara yang jauh lebih langsung untuk mengatakan bahwa fungsi tertentu secara eksplisit ditolak. Ini berlaku untuk mencegah alokasi tumpukan (yaitu, =deleteuntuk anggota operator new), mencegah salinan, penugasan, dll.
9. Templated typedef : Alias ​​templates di C ++ 11 mengurangi kebutuhan untuk typedef templated sederhana. Namun, generator tipe kompleks masih membutuhkan fungsi meta.
10. Beberapa perhitungan waktu kompilasi numerik, seperti Fibonacci dapat dengan mudah diganti menggunakan ekspresi konstan umum
11. result_of: Penggunaan templat kelas result_ofharus diganti dengan decltype. Saya pikir result_ofmenggunakan decltypeketika tersedia.
12. Inisialisasi anggota di dalam kelas menyimpan pengetikan untuk inisialisasi default anggota non-statis dengan nilai default.
13. Dalam kode C ++ 11 yang baru NULLharus didefinisikan ulang sebagai nullptr, tetapi lihat pembicaraan STL untuk mengetahui mengapa mereka memutuskan untuk tidak melakukannya.
14. Fanatik template ekspresi senang memiliki sintaks fungsi tipe trailing return di C ++ 11. Tidak ada lagi jenis pengembalian panjang 30-baris!

Saya pikir saya akan berhenti di sana!

Pada satu titik waktu dikatakan bahwa seseorang harus kembali dengan constnilai alih-alih hanya dengan nilai:

const A foo();
^^^^^

Ini sebagian besar tidak berbahaya di C ++ 98/03, dan mungkin bahkan menangkap beberapa bug yang terlihat seperti:

foo() = a;

Tapi kembali oleh constdikontraindikasikan dalam C ++ 11 karena menghambat semantik bergerak:

A a = foo();  // foo will copy into a instead of move into it

Jadi santai saja dan kode:

A foo();  // return by non-const value

Segera setelah Anda dapat meninggalkan 0dan NULLmendukung nullptr, lakukanlah!

Dalam kode non-generik, penggunaan 0atau NULLbukan merupakan masalah besar. Tetapi segera setelah Anda mulai melewati konstanta penunjuk nol dalam kode generik situasinya berubah dengan cepat. Ketika Anda lulus 0ke template<class T> func(T) Takan dideduksi sebagai intdan bukan sebagai pointer nol konstan. Dan itu tidak dapat dikonversi kembali ke konstanta penunjuk nol setelah itu. Ini mengalir ke rawa-rawa masalah yang sama sekali tidak ada jika alam semesta hanya digunakan nullptr.

C ++ 11 tidak usang 0dan NULLsebagai konstanta penunjuk nol. Tetapi Anda harus kode seolah-olah itu.

Idioma bool aman → explicit operator bool().

Pembuat salinan pribadi (boost :: noncopyable) → X(const X&) = delete

Mensimulasikan kelas terakhir dengan destruktor pribadi dan warisan virtual →class X final

Salah satu hal yang hanya membuat Anda menghindari penulisan algoritma dasar dalam C ++ 11 adalah ketersediaan lambdas dalam kombinasi dengan algoritma yang disediakan oleh perpustakaan standar.

Saya menggunakan itu sekarang dan itu luar biasa seberapa sering Anda hanya mengatakan apa yang ingin Anda lakukan dengan menggunakan count_if (), for_each () atau algoritma lain daripada harus menulis loop sialan lagi.

Setelah Anda menggunakan kompiler C ++ 11 dengan pustaka standar C ++ 11 yang lengkap, Anda tidak punya alasan lagi untuk tidak menggunakan algoritma standar untuk membangun . Lambda baru saja membunuhnya.

Mengapa?

Dalam prakteknya (setelah menggunakan cara penulisan algoritma ini sendiri) rasanya jauh lebih mudah untuk membaca sesuatu yang dibangun dengan kata-kata langsung yang berarti apa yang dilakukan daripada dengan beberapa loop yang harus Anda enkripsi untuk mengetahui artinya. Yang mengatakan, membuat argumen lambda secara otomatis menyimpulkan akan banyak membantu membuat sintaks lebih mudah dibandingkan dengan loop mentah.

Pada dasarnya, algoritma pembacaan yang dibuat dengan algoritma standar jauh lebih mudah karena kata-kata menyembunyikan detail implementasi loop.

Saya menduga hanya algoritma level yang lebih tinggi yang harus dipikirkan sekarang karena kita memiliki algoritma level yang lebih rendah untuk dibangun.

Anda harus menerapkan versi khusus yang swaplebih jarang. Dalam C ++ 03, non-throwing yang efisien swapsering diperlukan untuk menghindari mahal dan membuang salinan, dan karena std::swapmenggunakan dua salinan, swapsering kali harus disesuaikan. Dalam C ++, std::swappenggunaan move, dan fokusnya bergeser pada penerapan konstruktor pemindahan yang efisien dan non-lempar dan memindahkan penugasan Karena untuk ini default sering kali baik-baik saja, ini akan jauh lebih sedikit bekerja daripada di C ++ 03.

Secara umum sulit untuk memprediksi idiom mana yang akan digunakan karena mereka diciptakan melalui pengalaman. Kita dapat mengharapkan "Efektif C ++ 11" mungkin tahun depan, dan "Standar C ++ 11 Coding" hanya dalam tiga tahun karena pengalaman yang diperlukan belum ada di sana.

Saya tidak tahu nama untuk itu, tetapi kode C ++ 03 sering menggunakan konstruk berikut sebagai pengganti untuk tugas pindah yang hilang:

std::map<Big, Bigger> createBigMap(); // returns by value

void example ()
{
  std::map<Big, Bigger> map;

  // ... some code using map

  createBigMap().swap(map);  // cheap swap
}

Ini menghindari penyalinan karena salin salin digabungkan dengan di swapatas.

Ketika saya perhatikan bahwa kompiler yang menggunakan standar C ++ 11 tidak lagi kesalahan kode berikut:

std::vector<std::vector<int>> a;

untuk operator yang seharusnya berisi >>, saya mulai menari. Dalam versi sebelumnya yang harus dilakukan

std::vector<std::vector<int> > a;

Lebih buruk lagi, jika Anda harus men-debug ini, Anda tahu betapa mengerikannya pesan kesalahan yang keluar dari ini.

Namun, saya tidak tahu apakah ini "jelas" bagi Anda.

Pengembalian dengan nilai tidak lagi menjadi masalah. Dengan memindahkan semantik dan / atau optimalisasi nilai kembali (bergantung pada kompiler), fungsi pengkodean lebih alami tanpa overhead atau biaya (sebagian besar waktu).