Haruskah saya menggunakan fitur 'otomatis' C ++ 11 yang baru, terutama dalam loop?

Apa pro / kontra untuk menggunakan autokata kunci, terutama untuk loop?

for(std::vector<T>::iterator it = x.begin(); it != x.end(); it++ )
{
   it->something();
}

for(std::map<T>::iterator it = x.begin(); it != x.end(); it++ )
{
   it->second->something();
}

for(auto it = x.begin(); it != x.end(); it++ )
{
   it->??
}

Sepertinya jika Anda tidak tahu apakah Anda memiliki iterator untuk peta atau vektor Anda tidak akan tahu apakah akan digunakan firstatau secondatau hanya langsung akses properti dari objek, tidak ada?

Ini mengingatkan saya pada perdebatan C # tentang apakah akan menggunakan kata kunci var. Kesan yang saya dapatkan sejauh ini adalah bahwa di dunia C ++ orang siap untuk mengadopsi autokata kunci dengan sedikit perkelahian daripada vardi dunia C #. Bagi saya insting pertama saya adalah saya suka mengetahui jenis variabelnya sehingga saya bisa tahu operasi apa yang dapat saya lakukan untuk melakukannya.

Motivasi dalam C ++ lebih ekstrim, karena tipe bisa menjadi jauh lebih berbelit-belit dan kompleks daripada tipe C # karena metaprogramming dan hal-hal lain. autolebih cepat untuk menulis dan membaca dan lebih fleksibel / dipelihara daripada jenis eksplisit. Maksud saya, apakah Anda ingin mulai mengetik

boost::multi_map<NodeType, indexed_by<ordered_unique<identity<NodeType>>, hashed_non_unique<identity<NodeType>, custom_hasher>>::iterator_type<0> it

Itu bahkan bukan tipe lengkap. Saya melewatkan beberapa argumen templat.

Dalam contoh Anda:

for(auto it = x.begin(); it != x.end(); i++)
{
  it->??
}

harus ada deklarasi agar xterlihat. Karena itu jenisnya itharus jelas. Jika jenisnya xtidak jelas, maka metodenya terlalu panjang, atau kelasnya terlalu besar.

Keberatan ! Pertanyaan yang dimuat.

Bisakah Anda menjelaskan kepada saya mengapa kode ketiga ada ??di dalamnya, namun yang pertama dan kedua tidak? Demi keadilan, kode Anda harus dibaca sebagai berikut:

for(std::vector<T>::iterator it = x.begin(); it != x.end(); i++)
{
   it->???
}

for(std::map<T>::iterator it = x.begin(); it != x.end(); i++)
{
   it->second->???
}

Sana. Masalah yang sama meskipun Anda tidak menggunakannya auto.

Dan dalam semua kasus, jawabannya sama: Konteks penting . Anda tidak dapat berbicara secara bermakna tentang sepotong kode secara terpisah. Bahkan jika Anda tidak menggunakan template tetapi beberapa tipe konkret, ini hanya akan memindahkan masalah ke tempat lain, karena pembaca kode Anda harus tahu tentang deklarasi tipe tersebut.

Jika penggunaan autodalam situasi itu membuat kode Anda tidak dapat dibaca, Anda harus memperlakukan ini sebagai tanda peringatan bahwa ada sesuatu yang salah dengan desain kode Anda. Tentu saja, ada kasus-kasus di mana rincian tingkat rendah penting (seperti ketika berhadapan dengan operasi bit atau legacy API) di mana kasus tipe eksplisit dapat membantu keterbacaan. Namun secara umum - tidak.

Mengenai var(karena Anda menyebutkannya secara eksplisit), ada juga konsensus luas dalam komunitas C # untuk digunakan var. Argumen yang menentang penggunaannya umumnya dibangun di atas kekeliruan .

PRO

Kode Anda:

for(std::vector<T>::iterator it = x.begin(); it != x.end(); i++)

tidak akan dikompilasi, karena nama yang bergantung pada templat.

Ini adalah sintaks yang benar:

for( typename std::vector<T>::iterator it = x.begin(); it != x.end(); i++)

Sekarang lihat berapa lama deklarasi jenisnya. Ini menjelaskan mengapa autokata kunci diperkenalkan. Ini:

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

lebih ringkas. Jadi, ini adalah pro.

MENIPU

Anda harus sedikit berhati-hati. Dengan kata kunci auto, Anda mendapatkan tipe yang Anda nyatakan.

Sebagai contoh :

std::vector< int > v{ 1, 2, 3, 4 };
for ( auto it : v )
{
  ++ it;   // ops modifying copies of vector's elements
}

vs.

std::vector< int > v{ 1, 2, 3, 4 };
for ( auto & it : v )   // mind the reference
{
  ++ it;   // ok, vector's elements modified
}

Untuk menyimpulkan: ya, Anda harus melakukannya, tetapi tidak menggunakannya secara berlebihan. Beberapa orang cenderung menggunakannya terlalu banyak, dan menempatkan otomatis di mana-mana, seperti pada contoh berikut:

auto i = 0;

vs.

int i = 0;

Ya kamu harus! autotidak menghapus tipe; bahkan jika Anda "tidak tahu" apa x.begin()itu, kompiler tahu dan akan melaporkan kesalahan jika Anda mencoba menggunakan jenis itu secara salah. Juga, tidak biasa untuk ditiru mapdengan a vector<pair<Key,Value>>, sehingga penggunaan kode autoakan bekerja untuk kedua representasi kamus.

Ya, Anda harus menggunakan autosebagai aturan default. Ini memiliki keuntungan mentah dibandingkan dengan menentukan jenis:

• Itu tidak membuat Anda mengetik hal-hal yang sudah diketahui oleh kompiler.
• Itu membuat jenis variabel "ikuti" setiap perubahan dalam jenis nilai kembali.
• Melakukan hal itu, itu mencegah pengenalan diam-diam konversi implisit dan memotong inisialisasi variabel lokal.
• Ini menghilangkan kebutuhan beberapa jenis perhitungan eksplisit dalam template.
• Ini menghilangkan kebutuhan penamaan jenis kembali dengan nama panjang. (yang Anda salin-tempel dari diagnostik kompiler)

Di sinilah Anda punya pilihan. Ada juga kasus di mana Anda tidak punya pilihan:

• Ini memungkinkan deklarasi variabel dari tipe unutterable, seperti tipe lambda.

Asalkan Anda tahu persis apa yang autodilakukan, itu tidak memiliki kerugian.