Yeni C ++ 11 'otomatik' özelliğini, özellikle döngülerde kullanmalı mıyım?

autoAnahtar kelimeyi, özellikle döngüler için kullanmanın avantajları / dezavantajları nelerdir?

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

Eğer bir harita ya da bilemeyiz bir vektör için bir yineleyici sahip olup olmadığını bilmiyorsanız gibi görünüyor kullanımına olsun firstya secondveya nesnenin sadece doğrudan erişim özellikleri, hayır?

Bu bana anahtar kelimenin kullanılıp kullanılmayacağına dair C # tartışmasını hatırlatıyor var. Şimdiye kadar aldığım izlenim, C ++ dünyasında insanların C # dünyasından autodaha az kavga ile anahtar kelimeyi benimsemeye hazır olmaları var. Benim için ilk içgüdüm, değişkenin türünü bilmek istememdir, böylece üzerinde ne gibi işlemler yapmayı bekleyebilirim.

Metaprogramlama ve diğer şeyler nedeniyle türler C # türlerinden çok daha kıvrımlı ve karmaşık olabileceğinden, C ++ 'daki motivasyonlar daha aşırıdır. autoyazma ve okuma daha hızlıdır ve açık bir türden daha esnek / bakımı yapılabilir. Demek istediğim, yazmaya başlamak istiyor musun

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

Bu tam tip bile değil. Birkaç şablon argümanını kaçırdım.

Örneğinizde:

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

xgörünür olmak için bir deklarasyon olmalıdır . Bu nedenle türü itaçık olmalıdır. Türü xaçık değilse, yöntem çok uzun veya sınıf çok büyük.

İtiraz ! Yüklenen soru.

Üçüncü kodun neden içeride olduğunu açıklayabilir misiniz ??, yine de birinci ve ikinci kod yok? Adalet uğruna, kodunuz aşağıdaki gibi olmalıdır :

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

Orada. Kullanmasanız bile aynı sorun auto.

Ve her durumda, cevap aynıdır: Bağlam önemlidir . Bir kod parçasından ayrı olarak anlamlı bir şekilde konuşamazsınız. Şablon kullanmamış olsanız bile, somut bir tür kullanmış olsanız bile, bu sorunu sadece başka bir yere taşımış olabilirdi, çünkü kodunuzun okuyucusu bahsedilen türün bildirimini bilmek zorunda kalacaktı.

autoBu durumlarda kullanımı kodunuzu okunamaz hale getirirse, bunu kod tasarımınızda bir sorun olduğunu gösteren bir uyarı işareti olarak görmelisiniz. Tabii ki, düşük düzeyli ayrıntıların önemli olduğu durumlar vardır (bit işlemleri veya eski API ile uğraşırken olduğu gibi), bu tür durumlarda açık bir tür okunabilirliğe yardımcı olabilir. Ama genel olarak - hayır.

İlgili var(açıkça söz beri), bir de var engin konsensüs C # toplumda için kullanıyor var. Kullanımına karşı olan argümanlar genellikle yanlışlar üzerine kuruludur .

PRO

Senin kodun :

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

şablon bağımlı adı nedeniyle derlenmeyecektir.

Bu doğru sözdizimidir:

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

Şimdi tür bildiriminin ne kadar uzun olduğuna bakın. Bu, autoanahtar kelimenin neden tanıtıldığını gösterir. Bu :

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

daha özlü. Yani, bu bir profesyonel.

CON

Biraz dikkatli olmalısın. Anahtar kelime ile autobeyan ettiğiniz türü elde edersiniz.

Örneğin :

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
}

Sonuç olarak: evet, yapmalısınız, ama aşırı kullanmayın. Bazı insanlar bunu çok fazla kullanma eğilimindedir ve bir sonraki örnekte olduğu gibi her yere otomatik olarak yerleştirir:

auto i = 0;

vs

int i = 0;

Evet yapmalısın! autotürü silmez; ne x.begin()olduğunu "bilmiyorsanız" bile , derleyici türü yanlış kullanmaya çalıştığınızda bir hata bilir ve bildirir. Ayrıca, mapa ile taklit etmek olağandışı değildir vector<pair<Key,Value>>, bu nedenle kullanarak kod autoher iki sözlük temsili için de çalışır.

Evet, autovarsayılan kural olarak kullanmalısınız . Açıkça belirtmek yerine ham avantajları vardır:

• Derleyicinin zaten farkında olduğu şeyleri yazmanıza neden olmaz.
• Değişkenlerin türünü, dönüş değeri türlerindeki herhangi bir değişikliği "takip eder" yapar.
• Bunu yaparak , örtük dönüşümlerin sessizce başlatılmasını ve yerel değişken başlatmasında dilimlemeyi önler .
• Şablonlarda bazı açık tip hesaplamalara olan ihtiyacı ortadan kaldırır.
• Dönüş adlarını uzun adlarla adlandırma ihtiyacını ortadan kaldırır. (derleyici tanısından kopyalayıp yapıştırdıklarınız)

Burada bir seçim var. Başka seçeneğiniz olmadığı durumlar da vardır:

• Bir lambda türü gibi unutulabilir tipteki değişkenlerin bildirilmesine izin verir.

Tam olarak ne yaptığını bilmeniz koşuluyla auto, hiçbir dezavantajı yoktur.