Apakah otomatis membuat kode C ++ lebih sulit untuk dipahami?

Saya melihat sebuah konferensi oleh Herb Sutter di mana ia mendorong setiap programmer C ++ untuk menggunakannya auto.

Saya harus membaca kode C # beberapa waktu yang lalu di mana vardigunakan secara luas dan kode itu sangat sulit dipahami — setiap kali vardigunakan saya harus memeriksa kembali tipe sisi kanan. Terkadang lebih dari sekali, karena saya lupa jenis variabel setelah beberapa saat!

Saya tahu kompiler tahu jenisnya dan saya tidak harus menulisnya, tetapi secara luas diterima bahwa kita harus menulis kode untuk programmer, bukan untuk kompiler.

Saya juga tahu itu lebih mudah untuk ditulis:

auto x = GetX();

Dari:

someWeirdTemplate<someOtherVeryLongNameType, ...>::someOtherLongType x = GetX();

Tapi ini ditulis hanya sekali dan GetX()tipe kembalinya diperiksa berkali-kali untuk memahami tipe apa yang xdimiliki.

Ini membuat saya bertanya-tanya - apakah automembuat kode C ++ lebih sulit untuk dipahami?

Jawaban singkat: Secara lebih lengkap, pendapat saya saat ini autoadalah bahwa Anda harus menggunakan autosecara default kecuali Anda secara eksplisit menginginkan konversi. (Sedikit lebih tepatnya, "... kecuali jika Anda ingin secara eksplisit berkomitmen pada suatu jenis, yang hampir selalu karena Anda menginginkan konversi.")

Jawaban dan alasan yang lebih panjang:

Tulis jenis yang eksplisit (bukan auto) hanya ketika Anda benar-benar ingin berkomitmen secara eksplisit untuk suatu jenis, yang hampir selalu berarti Anda ingin secara eksplisit mendapatkan konversi ke jenis itu. Dari atas kepala saya, saya ingat dua kasus utama:

• (Biasa) initializer_listKejutan yang auto x = { 1 };menyimpulkan initializer_list. Jika Anda tidak mau initializer_list, ucapkan tipe - mis., Secara eksplisit minta konversi.
• (Rare) Kasus templat ekspresi, seperti yang auto x = matrix1 * matrix 2 + matrix3;menangkap jenis pembantu atau proxy yang tidak dimaksudkan untuk terlihat oleh programmer. Dalam banyak kasus, baik-baik saja dan jinak untuk menangkap jenis itu, tetapi kadang-kadang jika Anda benar-benar ingin itu runtuh dan melakukan perhitungan kemudian katakan jenisnya - yaitu, sekali lagi secara eksplisit meminta konversi.

autoSebaliknya, gunakan standar secara rutin , karena automenghindari jebakan dan membuat kode Anda lebih benar, lebih mudah dirawat, kuat, dan lebih efisien. Secara kasar, dari yang paling penting hingga yang paling tidak penting, dalam semangat "menulis untuk kejelasan dan kebenaran terlebih dahulu":

• Kebenaran: Menggunakan autojaminan Anda akan mendapatkan jenis yang tepat. Seperti kata pepatah, jika Anda mengulangi diri sendiri (ucapkan tipenya secara berlebihan), Anda bisa dan akan berbohong (salah). Berikut ini adalah contoh yang biasa: void f( const vector<int>& v ) { for( /*…*- pada titik ini, jika Anda menulis jenis iterator secara eksplisit, Anda ingin mengingat untuk menulis const_iterator(bukan?), Sedangkan yang autobenar saja.
• Maintainability dan robustness: Menggunakan automembuat kode Anda lebih kuat dalam menghadapi perubahan, karena ketika jenis ekspresi berubah, autoakan terus menyelesaikan ke jenis yang benar. Jika Anda lebih memilih komit ke tipe eksplisit, mengubah tipe ekspresi akan menyuntikkan konversi diam ketika tipe baru dikonversi ke tipe lama, atau build tidak perlu pecah ketika tipe baru masih berfungsi - seperti tipe lama tetapi tidak dikonversi ke yang lama ketik (misalnya, ketika Anda mengubah mapke unordered_map, yang selalu baik-baik saja jika Anda tidak bergantung pada pesanan, menggunakan autountuk iterator Anda Anda akan beralih dari map<>::iteratorke unordered_map<>::iterator, tetapi menggunakanmap<>::iterator di mana-mana secara eksplisit berarti Anda akan membuang-buang waktu berharga Anda pada riak memperbaiki kode mekanik, kecuali jika magang berjalan dan Anda dapat mengesampingkan pekerjaan yang membosankan pada mereka).
• Kinerja: Karena autotidak ada jaminan konversi implisit akan terjadi, itu menjamin kinerja yang lebih baik secara default. Jika sebaliknya Anda mengatakan jenisnya, dan itu membutuhkan konversi, Anda akan sering mendapatkan konversi diam-diam apakah Anda mengharapkannya atau tidak.
• Kegunaan: Menggunakan autoadalah satu-satunya pilihan Anda yang baik untuk jenis yang sulit untuk mengeja dan tidak dapat dihancurkan, seperti lambda dan bantuan templat, singkat menggunakan decltypeekspresi berulang atau tipuan kurang efisien seperti std::function.
• Kenyamanan: Dan, ya, autokurang mengetik. Saya menyebutkan bahwa terakhir untuk kelengkapan karena itu adalah alasan umum untuk menyukainya, tetapi itu bukan alasan terbesar untuk menggunakannya.

Oleh karena itu: Lebih suka mengatakannya autosecara default. Ini menawarkan begitu banyak kesederhanaan dan kinerja serta kejernihan yang baik sehingga Anda hanya menyakiti diri sendiri (dan pengelola kode Anda di masa mendatang) jika tidak. Hanya berkomitmen untuk jenis eksplisit ketika Anda benar-benar bersungguh-sungguh, yang hampir selalu berarti Anda menginginkan konversi eksplisit.

Ya, ada (sekarang) mengerti tentang hal ini.

Ini adalah situasi per kasus.

Terkadang membuat kode lebih sulit untuk dipahami, terkadang tidak. Ambil, misalnya:

void foo(const std::map<int, std::string>& x)
{
   for ( auto it = x.begin() ; it != x.end() ; it++ )
   { 
       //....
   }
}

jelas mudah dimengerti dan jelas lebih mudah untuk ditulis daripada deklarasi iterator yang sebenarnya.

Saya telah menggunakan C ++ untuk sementara waktu sekarang, tetapi saya dapat menjamin bahwa saya akan mendapatkan kesalahan kompiler pada kesempatan pertama saya karena saya akan melupakan const_iteratordan awalnya akan pergi untuk iterator... :)

Saya akan menggunakannya untuk kasus-kasus seperti ini, tetapi tidak di mana itu benar-benar mengaburkan jenis (seperti situasi Anda), tetapi ini murni subjektif.

Lihatlah dengan cara lain. Apakah Anda menulis:

std::cout << (foo() + bar()) << "\n";

atau:

// it is important to know the types of these values
int f = foo();
size_t b = bar();
size_t total = f + b;

std::cout << total << "\n";

Terkadang tidak membantu untuk mengeja jenis ini secara eksplisit.

Keputusan apakah Anda perlu menyebutkan jenis tidak sama dengan keputusan apakah Anda ingin membagi kode di beberapa pernyataan dengan mendefinisikan variabel perantara. Di C ++ 03 keduanya terhubung, Anda dapat menganggapnya autosebagai cara untuk memisahkan mereka.

Kadang-kadang membuat tipe eksplisit dapat berguna:

// seems legit    
if (foo() < bar()) { ... }

vs.

// ah, there's something tricky going on here, a mixed comparison
if ((unsigned int)foo() < bar()) { ... }

Dalam kasus di mana Anda mendeklarasikan variabel, menggunakan automembiarkan tipe tidak terucapkan seperti halnya dalam banyak ekspresi. Anda mungkin harus mencoba memutuskan sendiri kapan hal itu membantu keterbacaan dan kapan hal itu menghalangi.

Anda dapat berargumen bahwa memadukan tipe yang bertanda tangan dan tidak bertanda merupakan kesalahan sejak awal (memang, beberapa orang berpendapat lebih jauh bahwa seseorang tidak boleh menggunakan jenis yang tidak bertanda sama sekali). The Alasan itu bisa dibilang kesalahan adalah membuat jenis operan sangat penting karena perilaku yang berbeda. Jika Anda perlu mengetahui jenis-jenis nilai Anda, itu mungkin juga bukan hal buruk untuk tidak perlu mengetahuinya. Jadi asalkan kode tersebut belum membingungkan karena alasan lain, itu tidak autoapa-apa, kan? ;-)

Khususnya ketika menulis kode generik ada kasus di mana jenis sebenarnya dari variabel tidak boleh penting, yang penting adalah bahwa itu memenuhi antarmuka yang diperlukan. Jadi autoberikan tingkat abstraksi di mana Anda mengabaikan jenisnya (tapi tentu saja kompiler tidak, ia tahu). Bekerja pada level abstraksi yang sesuai dapat membantu keterbacaan cukup banyak, bekerja pada level "salah" membuat pembacaan kode menjadi pekerjaan berat.

IMO, Anda melihat ini secara terbalik.

Bukan masalah automengarah ke kode yang tidak dapat dibaca atau bahkan kurang dapat dibaca. Ini masalah (berharap bahwa) memiliki tipe eksplisit untuk nilai pengembalian akan menggantikan fakta bahwa (tampaknya) tidak jelas tipe apa yang akan dikembalikan oleh beberapa fungsi tertentu.

Setidaknya menurut saya, jika Anda memiliki fungsi yang tipe pengembaliannya tidak segera jelas, itu masalah Anda di sana. Apa fungsi itu harus jelas dari namanya, dan jenis nilai pengembalian harus jelas dari apa yang dilakukannya. Jika tidak, itulah sumber masalahnya.

Jika ada masalah di sini, bukan dengan auto. Ini dengan sisa kode, dan kemungkinan cukup bagus bahwa jenis eksplisit hanya cukup band-bantuan untuk membuat Anda melihat dan / atau memperbaiki masalah inti. Setelah Anda memperbaiki masalah nyata itu, keterbacaan kode menggunakan autoumumnya akan baik-baik saja.

Saya kira secara adil saya harus menambahkan: Saya sudah berurusan dengan beberapa kasus di mana hal-hal seperti itu tidak sejelas yang Anda inginkan, dan memperbaiki masalah juga tidak bisa dipertahankan. Sebagai contoh, saya melakukan konsultasi untuk sebuah perusahaan beberapa tahun yang lalu yang sebelumnya bergabung dengan perusahaan lain. Mereka berakhir dengan basis kode yang lebih "didorong bersama" daripada benar-benar bergabung. Program konstituen sudah mulai menggunakan perpustakaan yang berbeda (tapi sangat mirip) untuk tujuan yang sama, dan meskipun mereka bekerja untuk menggabungkan hal-hal yang lebih bersih, mereka masih melakukannya. Dalam banyak kasus, satu-satunya cara untuk menebak jenis apa yang akan dikembalikan oleh fungsi yang diberikan adalah untuk mengetahui dari mana fungsi itu berasal.

Bahkan dalam kasus seperti itu, Anda dapat membantu membuat beberapa hal menjadi lebih jelas. Dalam hal ini, semua kode dimulai di namespace global. Cukup memindahkan jumlah yang wajar ke beberapa ruang nama menghilangkan bentrokan nama dan sedikit memudahkan pelacakan tipe.

Ada beberapa alasan mengapa saya tidak suka otomatis untuk penggunaan umum:

1. Anda dapat memperbaiki kode tanpa mengubahnya. Ya, ini adalah salah satu hal yang sering didaftar sebagai manfaat menggunakan otomatis. Ubah saja tipe fungsi yang dikembalikan, dan jika semua kode yang memanggilnya menggunakan otomatis, tidak diperlukan upaya tambahan! Anda menekan kompilasi, itu membangun - 0 peringatan, 0 kesalahan - dan Anda hanya melanjutkan dan memeriksa kode Anda tanpa harus berurusan dengan kekacauan melihat-lihat dan berpotensi memodifikasi 80 tempat fungsi digunakan.

Tapi tunggu, apakah itu ide yang bagus? Bagaimana jika jenisnya penting dalam setengah lusin kasus penggunaan tersebut, dan sekarang kode itu benar-benar berperilaku berbeda? Ini juga secara implisit dapat memecahkan enkapsulasi, dengan memodifikasi tidak hanya nilai input, tetapi perilaku itu sendiri dari implementasi privat dari kelas lain yang memanggil fungsi.

1a. Saya seorang yang percaya pada konsep "kode dokumentasi diri". Alasan di balik kode dokumentasi diri adalah bahwa komentar cenderung menjadi ketinggalan zaman, tidak lagi mencerminkan apa yang dilakukan kode, sedangkan kode itu sendiri - jika ditulis secara eksplisit - jelas, selalu tetap up to date. pada niatnya, dan tidak akan membuat Anda bingung dengan komentar basi. Jika tipe dapat diubah tanpa perlu memodifikasi kode itu sendiri, maka kode / variabel itu sendiri dapat menjadi basi. Sebagai contoh:

auto bThreadOK = CheckThreadHealth ();

Kecuali masalahnya adalah bahwa CheckThreadHealth () di beberapa titik telah di refactored untuk mengembalikan nilai enum yang menunjukkan status kesalahan, jika ada, bukan bool. Tetapi orang yang melakukan perubahan itu gagal memeriksa baris kode khusus ini, dan kompiler tidak membantu karena dikompilasi tanpa peringatan atau kesalahan.

2. Anda mungkin tidak pernah tahu apa tipe sebenarnya. Ini juga sering terdaftar sebagai "manfaat" utama otomatis. Mengapa belajar apa fungsi memberi Anda, ketika Anda bisa mengatakan, "Siapa yang peduli? Itu mengkompilasi!"

Bahkan jenis pekerjaan, mungkin. Saya mengatakan jenis pekerjaan, karena meskipun Anda membuat salinan struct 500 byte untuk setiap iterasi loop, sehingga Anda dapat memeriksa nilai tunggal di dalamnya, kode masih berfungsi sepenuhnya. Jadi, bahkan pengujian unit Anda tidak membantu Anda menyadari bahwa kode buruk bersembunyi di balik otomatis yang sederhana dan tampak tidak bersalah itu. Kebanyakan orang lain memindai file tidak akan melihatnya pada pandangan pertama juga.

Ini juga dapat menjadi lebih buruk jika Anda tidak tahu apa jenisnya, tetapi Anda memilih nama variabel yang membuat asumsi yang salah tentang apa itu, pada dasarnya mencapai hasil yang sama seperti pada 1a, tetapi sejak awal bukan pasca-refactor.

3. Mengetik kode ketika awalnya menulis itu bukan bagian yang paling memakan waktu dari pemrograman. Ya, otomatis membuat penulisan beberapa kode lebih cepat pada awalnya. Sebagai penafian, saya mengetik> 100 WPM, jadi mungkin itu tidak mengganggu saya sebanyak yang lain. Tetapi jika yang harus saya lakukan adalah menulis kode baru sepanjang hari, saya akan menjadi kemping yang bahagia. Bagian pemrograman yang paling banyak menghabiskan waktu adalah mendiagnosis bug tepi-kode yang sulit direproduksi, sering kali merupakan hasil dari masalah tidak jelas yang tidak jelas - seperti penggunaan mobil yang terlalu sering digunakan (referensi vs. salinan, ditandatangani vs. unsigned, float vs. int, bool vs. pointer, dll.).

Tampak jelas bagi saya bahwa otomatis diperkenalkan terutama sebagai solusi untuk sintaks yang mengerikan dengan tipe templat perpustakaan standar. Alih-alih mencoba memperbaiki sintaks templat yang sudah dikenal banyak orang - yang mungkin juga hampir mustahil dilakukan karena semua kode yang ada dapat rusak - tambahkan kata kunci yang pada dasarnya menyembunyikan masalah. Pada dasarnya apa yang Anda sebut "hack".

Saya sebenarnya tidak memiliki ketidaksetujuan dengan penggunaan otomatis dengan kontainer perpustakaan standar. Ini jelas untuk apa kata kunci itu dibuat, dan fungsi-fungsi di perpustakaan standar tidak mungkin secara mendasar mengubah tujuan (atau tipe dalam hal ini), membuat otomatis relatif aman untuk digunakan. Tetapi saya akan sangat berhati-hati dalam menggunakannya dengan kode dan antarmuka Anda sendiri yang mungkin jauh lebih tidak stabil, dan berpotensi mengalami perubahan yang lebih mendasar.

Aplikasi lain yang berguna dari auto yang meningkatkan kemampuan bahasa adalah membuat temporaries dalam macro type-agnostic. Ini adalah sesuatu yang tidak bisa Anda lakukan sebelumnya, tetapi Anda bisa melakukannya sekarang.

Ya, akan lebih mudah untuk mengetahui jenis variabel Anda jika Anda tidak menggunakannya auto. Pertanyaannya adalah: apakah Anda perlu tahu jenis variabel Anda untuk membaca kode? Terkadang jawabannya adalah ya, kadang tidak. Misalnya, ketika mendapatkan sebuah iterator dari std::vector<int>, yang perlu Anda tahu bahwa itu adalah std::vector<int>::iteratoratau akan auto iterator = ...;cukup? Segala sesuatu yang orang ingin lakukan dengan iterator diberikan oleh fakta itu iterator - hanya saja tidak peduli apa jenisnya secara spesifik.

Gunakan autodalam situasi itu ketika itu tidak membuat kode Anda lebih sulit untuk dibaca.

Secara pribadi saya autohanya menggunakan ketika benar-benar jelas bagi programmer apa itu.

Contoh 1

std::map <KeyClass, ValueClass> m;
// ...
auto I = m.find (something); // OK, find returns an iterator, everyone knows that

Contoh 2

MyClass myObj;
auto ret = myObj.FindRecord (something)// NOT OK, everyone needs to go and check what FindRecord returns

Pertanyaan ini mengumpulkan opini, yang akan bervariasi dari satu programmer ke programmer lainnya, tetapi saya akan mengatakan tidak. Bahkan dalam banyak kasus justru sebaliknya, autodapat membantu membuat kode lebih mudah dipahami dengan memungkinkan programmer untuk fokus pada logika daripada hal-hal kecil.

Ini terutama benar dalam menghadapi tipe template yang kompleks. Berikut adalah contoh yang disederhanakan & dibuat-buat. Mana yang lebih mudah dipahami?

for( std::map<std::pair<Foo,Bar>, std::pair<Baz, Bot>, std::less<BazBot>>::const_iterator it = things_.begin(); it != things_.end(); ++it )

.. atau...

for( auto it = things_.begin(); it != things_.end(); ++it )

Beberapa akan mengatakan yang kedua lebih mudah dimengerti, yang lain mungkin mengatakan yang pertama. Namun yang lain mungkin mengatakan bahwa penggunaan gratis autodapat berkontribusi untuk mematikan programmer yang menggunakannya, tapi itu cerita lain.

Banyak jawaban bagus sejauh ini, tetapi untuk fokus pada pertanyaan awal, saya pikir Herb terlalu jauh dalam sarannya untuk menggunakan autosecara bebas. Contoh Anda adalah satu kasus di mana penggunaan autojelas menyakitkan keterbacaan. Beberapa orang bersikeras itu bukan masalah dengan IDE modern di mana Anda dapat mengarahkan variabel dan melihat jenisnya, tetapi saya tidak setuju: bahkan orang yang selalu menggunakan IDE terkadang perlu melihat potongan kode secara terpisah (pikirkan ulasan kode) , misalnya) dan IDE tidak akan membantu.

Intinya: gunakan autoketika itu membantu: mis. Iterators in for loop. Jangan menggunakannya saat itu membuat pembaca kesulitan untuk mengetahui jenisnya.

Saya cukup terkejut bahwa belum ada yang menunjukkan bahwa otomatis membantu jika tidak ada tipe yang jelas. Dalam kasus ini, Anda dapat mengatasi masalah ini dengan menggunakan #define atau typedef dalam templat untuk menemukan jenis yang sebenarnya dapat digunakan (dan ini kadang-kadang tidak sepele), atau Anda hanya menggunakan otomatis.

Misalkan Anda memiliki fungsi, yang mengembalikan sesuatu dengan tipe platform-spesifik:

#ifdef PLATFROM1
__int256 getStuff();
#else //PLATFORM2
__int128 getStuff();
#endif

Penggunaan penyihir yang Anda inginkan?

#ifdef PLATFORM1
__int256 stuff = getStuff();
#else
__int128 stuff = getStuff();
#endif

atau hanya sederhana

auto stuff = getStuff();

Tentu, Anda bisa menulis

#define StuffType (...)

juga di suatu tempat, tetapi tidak

StuffType stuff = getStuff();

sebenarnya memberi tahu lebih banyak tentang tipe x? Mengatakan itu adalah apa yang dikembalikan dari sana, tetapi itulah yang otomatis. Ini hanya mubazir - 'barang' ditulis 3 kali di sini - ini menurut saya membuatnya kurang mudah dibaca daripada versi 'otomatis'.

Keterbacaan itu subyektif; Anda harus melihat situasi dan memutuskan yang terbaik.

Seperti yang Anda tunjukkan, tanpa otomatis, deklarasi panjang dapat menghasilkan banyak kekacauan. Tetapi seperti yang Anda tunjukkan, deklarasi pendek dapat menghapus informasi jenis yang mungkin berharga.

Selain itu, saya juga akan menambahkan ini: pastikan Anda melihat keterbacaan dan bukan kemampuan menulis. Kode yang mudah ditulis umumnya tidak mudah dibaca dan sebaliknya. Misalnya, jika saya menulis, saya lebih suka otomatis. Jika saya membaca, mungkin deklarasi yang lebih panjang.

Lalu ada konsistensi; seberapa pentingkah hal itu bagi Anda? Apakah Anda ingin otomatis di beberapa bagian dan deklarasi eksplisit di bagian lain, atau satu metode yang konsisten di seluruh?

Saya akan mengambil titik kode yang kurang dapat dibaca sebagai keuntungan, dan akan mendorong programmer untuk menggunakannya lebih dan lebih. Mengapa? Jelas jika kode menggunakan otomatis sulit dibaca, maka akan sulit juga untuk menulis. Programmer dipaksa untuk menggunakan nama variabel yang bermakna , untuk membuat pekerjaannya lebih baik.
Mungkin pada awalnya programmer tidak dapat menulis nama variabel yang bermakna. Tetapi pada akhirnya ketika memperbaiki bug, atau dalam tinjauan kode, ketika dia harus menjelaskan kode tersebut kepada orang lain, atau dalam waktu yang tidak begitu dekat, dia menjelaskan kode kepada orang pemeliharaan, programmer akan menyadari kesalahan dan akan menggunakan nama variabel yang bermakna di masa depan.

Saya punya dua pedoman:

• Jika jenis variabelnya jelas, membosankan untuk ditulis atau sulit untuk menentukan penggunaan otomatis.

  auto range = 10.0f; // Obvious
  
  for (auto i = collection.cbegin(); i != cbegin(); ++i) // Tedious if collection type
  // is really long
  
  template <typename T> ... T t; auto result = t.get(); // Hard to determine as get()
  // might return various stuff

• Jika Anda memerlukan konversi tertentu atau jenis hasilnya tidak jelas dan dapat menyebabkan kebingungan.

  class B : A {}; A* foo = new B(); // 'Convert'
  
  class Factory { public: int foo(); float bar(); }; int f = foo(); // Not obvious

Iya. Ini mengurangi verbositas tetapi kesalahpahaman yang umum adalah bahwa verbositas mengurangi keterbacaan. Ini hanya benar jika Anda menganggap keterbacaan sebagai estetika daripada kemampuan Anda yang sebenarnya untuk kode intepret - yang tidak meningkat dengan menggunakan otomatis. Dalam contoh yang paling sering dikutip, vektor iterator, itu mungkin muncul di permukaan yang menggunakan otomatis meningkatkan keterbacaan kode Anda. Di sisi lain, Anda tidak selalu tahu apa kata kunci otomatis akan memberi Anda. Anda harus mengikuti jalur logis yang sama seperti yang dilakukan oleh kompiler untuk melakukan rekonstruksi internal, dan seringkali, khususnya dengan iterator, Anda akan membuat asumsi yang salah.

Pada akhirnya, 'otomatis' mengorbankan keterbacaan kode dan kejelasan, untuk 'kebersihan' sintaksis dan estetika (yang hanya diperlukan karena iterator memiliki sintaks yang berbelit-belit tidak perlu) dan kemampuan untuk mengetik 10 karakter lebih sedikit pada setiap baris yang diberikan. Itu tidak sepadan dengan risikonya, atau upaya yang dilakukan untuk jangka panjang.