C ++ 11 otomatik anahtar kelimesi ile ne kadar çok şey var?

autoC ++ 11 standardında mevcut olan yeni anahtar kelimeyi, bunun için tasarlandığına inandığım karmaşık şablonlu türler için kullanıyorum. Ama aynı zamanda şu gibi şeyler için kullanıyorum:

auto foo = std::make_shared<Foo>();

Ve daha şüpheci olanlar:

auto foo = bla(); // where bla() return a shared_ptr<Foo>

Bu konuda çok fazla tartışma görmedim. Gibi görünüyor autobir tür dokümantasyon ve sağlıklı çalışma kontrolü şeklidir genellikle olduğundan, gereksiz yere edilebilir. Kullanım sırasında çizgiyi nerede çiziyorsunuz ve autobu yeni özellik için önerilen kullanım durumları nelerdir?

Açıklığa kavuşturmak için: Felsefi bir görüş istemiyorum; Muhtemelen bu kullanımın pratikte nasıl gerçekleştirildiğine dair yorumlarla, standart komite tarafından bu anahtar kelimenin amaçlanan kullanımını istiyorum.

Yan not: Bu soru SE.Programmers'a ve ardından Stack Overflow'a taşındı. Bununla ilgili tartışma bu meta soruda bulunabilir .

Ben autoilk bakışta türü yazmak için nasıl söylemek zor her zaman anahtar kelime kullanmak gerektiğini düşünüyorum , ancak bir ifadenin sağ tarafının türü açıktır. Örneğin, şunu kullanarak:

my_multi_type::nth_index<2>::type::key_type::composite_key_type::
    key_extractor_tuple::tail_type::head_type::result_type

Bileşik anahtar türünü girmek için boost::multi_index, biliyor olsanız bile int. Sadece yazamazsınız intçünkü gelecekte değiştirilebilir. Ben yazardım autobu durumda.

Dolayısıyla, autoanahtar kelime belirli bir durumda okunabilirliği artırırsa kullanın. autoOkuyucunun ne tür bir autoifadeyi temsil ettiği açık olduğunda yazabilirsiniz .

İşte bazı örnekler:

auto foo = std::make_shared<Foo>();   // obvious
auto foo = bla();                     // unclear. don't know which type `foo` has

const size_t max_size = 100;
for ( auto x = max_size; x > 0; --x ) // unclear. could lead to the errors
                                      // since max_size is unsigned

std::vector<some_class> v;
for ( auto it = v.begin(); it != v.end(); ++it )
                                      // ok, since I know that `it` has an iterator type
                                      // (don't really care which one in this context)

Mümkün olan autoher yerde kullanın - özellikle const autoyan etkiler daha az endişe uyandırır. Açık durumlar dışında türler hakkında endişelenmenize gerek yoktur, ancak yine de sizin için statik olarak doğrulanırlar ve bazı tekrarlardan kaçınabilirsiniz. Mümkün autoolmadığı durumlarda, decltypetürleri anlamsal olarak ifadelere dayalı sözleşmeler olarak ifade etmek için kullanabilirsiniz . Kodunuz farklı görünecek, ancak olumlu bir değişiklik olacak.

Kolay. Türün ne olduğunu umursamadığınızda kullanın . Örneğin

for (const auto & i : some_container) {
   ...

Burada umursadığım tek şey ikapta ne varsa.

Biraz typedefs gibi.

typedef float Height;
typedef double Weight;
//....
Height h;
Weight w;

Burada, umurumda olmadığını değil hve wonlar sadece o, yüzen veya çiftler vardır yükseklikleri ve ağırlıkları ifade etmek uygundur ne olursa olsun tipi .

Veya düşünün

for (auto i = some_container .begin (); ...

Burada umursadığım tek şey bunun uygun bir yineleyici, destekleyici olması operator++(), bu açıdan ördek yazması gibi.

Ayrıca lambdas türü yazılamaz, bu yüzden auto f = []...iyi bir stil. Alternatif döküm yapmaktır, std::functionancak bu havai gelir.

Gerçekten "kötüye kullanımı" idrak edemiyorum auto. Hayal edebileceğim en yakın şey, kendinizi önemli bir türe açık bir dönüşümden mahrum etmektir - ancak bunun için kullanmazsınız auto, istediğiniz türde bir nesne inşa edersiniz.

Eğer varsa olabilir yan etkileri tanıtan olmadan kodunda bazı fazlalık kaldırmak, o zaman gerekir bunu yapmak için iyi olmak.

Karşı örnekler (başkasının cevaplarından ödünç alınmıştır):

auto i = SomeClass();
for (auto x = make_unsigned (y); ...)

Burada tipin ne olduğunu önemsiyoruz, bu yüzden yazmalıyız Someclass i;vefor(unsigned x = y;...

Göreyim seni. autoKod yazmayı kolaylaştıran her yerde kullanın .

Herhangi bir dilde her yeni özellik, en azından bazı programcılar tarafından aşırı kullanılacaktır. Tecrübeli programcıların geri kalanı uygun kullanımın sınırlarını öğrenmeleri sadece bazı deneyimli programcılar (noobs değil) tarafından orta düzeyde aşırı kullanım yoluyla gerçekleşir. Aşırı aşırı kullanım genellikle kötüdür, ancak iyi olabilir, çünkü bu aşırı kullanım özellikte iyileştirmelere veya onun yerine daha iyi bir özelliğe neden olabilir.

Ama kod gibi birkaç satırdan fazla çalışsaydım

auto foo = bla();

türün sıfır kez belirtildiği yerlerde, bu satırları türleri içerecek şekilde değiştirmek isteyebilirim. İlk örnek, tür bir kez belirtildiği için harika ve autodağınık şablonlu türleri iki kez yazmaktan kurtarıyor. C ++++ için Yaşasın. Ancak açık bir şekilde sıfır kez göstermek, eğer yakındaki bir çizgide kolayca görünmüyorsa, en azından C ++ ve onun ardıllarında beni sinirlendiriyor. Daha soyutlama, çok biçimlilik ve jeneriklikle daha yüksek seviyede çalışmak üzere tasarlanmış diğer diller için sorun yok.

At C ++ ve Ötesi 2012 yılında sor Us şey panelinde, bir yoktu kullanmak ve kullanmak için ne zaman söz Andrei Alexandrescu'nun Scott Meyers ve Herb Sutter arasındaki fantastik değişimiauto . 4 dakikalık bir tartışma için 25:03. Dakikaya geçin. Her üç hoparlörler için zaman için akılda tutulmalıdır mükemmel noktaları vermek değil kullanın auto.

Çok kendi sonuca etmeye teşvik ama benim take away oldu kullanmak autoher yerde sürece :

1. Okunabilirliği acıtıyor
2. Otomatik tür dönüştürmeyle ilgili endişe vardır (örn. Yapıcılar, atama, şablon ara türleri, tamsayı genişlikleri arasında örtük dönüşüm)

Liberal kullanımı explicit, ikincisi için endişeyi azaltmaya yardımcı olur, bu da birincinin sorun olduğu süreyi en aza indirmeye yardımcı olur.

Herb'in söylediklerini yeniden çizerek, "X, Y ve Z yapmıyorsanız kullanın auto. X, Y ve Z'nin ne olduğunu öğrenin ve devam edin ve autobaşka her yerde kullanın ."

Evet, okunabilirlik zararına aşırı kullanılabilir. Kesin tiplerin uzun, unutulabilir veya okunabilirlik açısından önemli olmadığı ve değişkenlerin kısa ömürlü olduğu bağlamlarda kullanılmasını öneririm. Örneğin, yineleyici türü genellikle uzundur ve önemli değildir, bu yüzden autoişe yarar:

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

auto burada okunabilirliğe zarar vermez.

Başka bir örnek, uzun ve kıvrımlı olabilen ayrıştırıcı kural türüdür. Karşılaştırmak:

   auto spaces = space & space & space;

ile

r_and_t<r_and_t<r_char_t<char>&, r_char_t<char>&>, r_char_t<char>&> spaces = 
   space & space & space;

Öte yandan, tür bilindiğinde ve basit olduğunda, açıkça belirtilmesi daha iyidir:

int i = foo();

ziyade

auto i = foo();

auto Eigen veya OpenCV gibi doğrusal cebir kütüphaneleri tarafından çok kullanılan ifade şablonlarıyla birlikte çok tehlikeli olabilir.

auto A = Matrix(...);
auto B = Matrix(...);
auto C = A * B; // C is not a matrix. It is a matrix EXPRESSION.
cout << C; // The expression is evaluated and gives the expected result.
... // <code modifying A or B>
cout << C; // The expression is evaluated AGAIN and gives a DIFFERENT result.

Bu tür hatalardan kaynaklanan hatalar hata ayıklamak için büyük bir acıdır. Olası bir çözüm, soldan sağa bildirim stili için otomatik kullanma konusunda cehennem iseniz, sonucu beklenen türe açıkça atamaktır.

auto C = Matrix(A * B); // The expression is now evaluated immediately.

Ben autokısıtlama olmadan kullanın ve herhangi bir sorunla karşılaşmadım. Bazen basit tipler için bile kullanıyorum int. Bu, c ++ 'ı benim için daha yüksek bir dil yapar ve c ++' da python'da olduğu gibi değişken bildirmeye izin verir. Python kodunu yazdıktan sonra, bazen örneğin;

auto i = MyClass();

onun yerine

MyClass i;

Bu, autoanahtar kelimenin kötüye kullanılması olduğunu söyleyeceğim bir durum .

Genellikle nesnenin tam türünün ne olduğunu umursamıyorum, onun işlevliliğiyle daha fazla ilgileniyorum ve işlev adları genellikle geri döndükleri nesneler hakkında bir şey söylediğinden, autoincinmez: örneğin auto s = mycollection.size(), tahmin sedeceğim bu bir tür tamsayı ve tam türü önemsediğim nadir durumlarda, işlev prototipini kontrol edelim (yani, kod yazıldığında bir önsel yerine bilgiye ihtiyacım olduğunda kontrol etmeyi tercih ederim, sadece olduğu gibi bir gün yararlı olacağı takdirde int_type s = mycollection.size()).

Kabul edilen cevaptan bu örnekle ilgili olarak:

for ( auto x = max_size; x > 0; --x )

Kodumda hala autobu durumda kullanıyorum ve eğer ximzasız olmak istiyorsanız , o zaman say adlı make_unsignedaçık bir şekilde kaygılarımı ifade eden bir yardımcı işlev kullanıyorum :

for ( auto x = make_unsigned(max_size); x > 0; --x )

Feragatname: Sadece kullanımımı tarif ediyorum , tavsiye vermeye yetkili değilim!

C ++ programının en büyük sorunlarından biri , başlatılmamış değişkeni kullanmanıza izin vermesidir . Bu bizi kötü bir deterministik olmayan program davranışına götürür. Program lastiklerinin kullanması durumunda modern derleyicinin artık uygun / mesaj uyarı mesajları attığına dikkat edilmelidir.

Sadece bunu göstermek için, c ++ programını aşağıda düşünün:

int main() {
    int x;
    int y = 0;
    y += x;
}

Bu programı modern derleyici (GCC) kullanarak derlersem, uyarı verir. Gerçek karmaşık üretim koduyla çalışıyorsak, bu uyarı çok açık olmayabilir.

main.cpp: 'int main ()' işlevinde:

main.cpp: 4: 8: uyarı : 'x' bu işlevde başlatılmamış olarak kullanılır [-Wuninitialized]

y + = x;

    ^

================================================== =============================== Şimdi otomatik kullanan programımızı değiştirirsek , derleriz:

int main() {
    auto x;
    auto y = 0;
    y += x;
}

main.cpp: 'int main ()' işlevinde:

main.cpp: 2: 10: hata : 'auto x' bildiriminin başlatıcısı yok

 auto x;

      ^

Otomatik ile, başlatılmamış değişkeni kullanmak mümkün değildir. Bu, otomatik kullanmaya başlarsak (ücretsiz) alabileceğimiz büyük bir avantajdır .

Bu kavram ve diğer büyük büyük modern C ++ konsepti, C ++ uzmanı Herb Shutter tarafından CppCon14 konuşmasında açıklanmıştır:

Geri Temel Bilgiler! Modern C ++ Stilinin Temelleri

Belirttiğim bir tehlike referans açısından. Örneğin

MyBigObject& ref_to_big_object= big_object;
auto another_ref = ref_to_big_object; // ?

Sorun another_ref aslında bir referans değil, bu durumda MyBigObject & yerine MyBigObject olmasıdır. Sonunda büyük bir nesneyi fark etmeden kopyalarsınız.

Doğrudan bir yöntemden referans alıyorsanız, bunun gerçekte ne olduğunu düşünemeyebilirsiniz.

auto another_ref = function_returning_ref_to_big_object();

"otomatik" veya "sabit otomatik &"

MyBigObject& ref_to_big_object= big_object;
auto& another_ref = ref_to_big_object;
const auto& yet_another_ref = function_returning_ref_to_big_object();

autoBir türün çıkarılmasının mantıklı olduğu yerlerde kullanın . Eğer bir tamsayı olduğunu bildiğiniz bir şey varsa, ya da bir dize olduğunu biliyorsanız, sadece int / std :: string, vb. Kullanın. Saçma noktasına gelmedikçe, bir dil özelliğini "aşırı kullanmak" için endişelenmezdim, veya kodu gizler.

Zaten bu benim fikrim.

autoanahtar kelime yalnızca yerel değişken için kullanılabilir, bağımsız değişkenler veya sınıf / yapı üyeleri için kullanılamaz. Bu nedenle, istediğiniz yerde kullanmak güvenli ve uygulanabilir. Onları çok kullanıyorum. Tür derleme zamanında çıkarılır, hata ayıklayıcı hata ayıklama sırasında türü gösterir, sizeofdoğru raporlar, decltypedoğru türü verir - hiçbir zararı yoktur. autoAşırı kullanılmış sayılmaz , asla!

TL; DR: Bkz. Alttaki kural.

Kabul edilen cevap aşağıdaki temel kuralı önermektedir:

autoTürü ilk bakışta nasıl yazacağınızı söylemek zor olduğunda kullanın , ancak bir ifadenin sağ tarafının türü açıktır.

Ama bunun çok kısıtlayıcı olduğunu söyleyebilirim. Bazen türler umurumda değil, çünkü ifade türünü anlamaya zaman ayırmak için uğraşmadan yeterince bilgilendirici. Bununla ne demek istiyorum? Bazı cevaplarda ortaya çıkan örneği düşünün:

auto x = f();

Bunu suistimalin bir örneği yapan nedir auto? f()Dönüş türünü bilmiyor muyum? Biliyorsam gerçekten yardımcı olabilir, ama - bu benim asıl endişem değil. Ne çok daha bir sorun olmasıdır xve f()oldukça anlamsızdır. Eğer olsaydı:

auto nugget = mine_gold();

bunun yerine, genellikle işlevin dönüş türünün açık olup olmadığı umurumda değildir. İfadeyi okuduğumda, ne yaptığımı biliyorum ve dönüş değerinin semantiğinin ne tür olduğunu bilmem için yeterli olduğunu biliyorum.

Benim cevabım şöyledir: autoDerleyici izin verdiği her durumda kullanın.

• Değişken adının başlatma / atama ifadesiyle birlikte ifadenin ne yaptığı hakkında yeterli bilgi sağlamadığını hissedersiniz.
• Değişken adını, başlatma / atama ifadesi ile birlikte türün ne olması gerektiği hakkında "yanıltıcı" bilgiler sağladığını hissedersiniz - yani, otomatik yerine ne olduğunu tahmin etmek zorunda olsaydınız, tahmin edebileceksiniz - ve yanlıştır ve bu yanlış varsayım kodun ilerleyen bölümlerinde yansımalar içerir.
• Farklı bir türü zorlamak istiyorsunuz (örn. Başvuru).

Ve ayrıca:

• autoSomut tiple değiştirmeden önce anlamlı bir isim vermeyi tercih edin (elbette tip adını içermez) .

İle benim acı deneyim biri autoolan lambda ifadeleri ile kullanmaktan :

auto i = []() { return 0; };
cout<<"i = "<<i<<endl; // output: 1 !!!

Aslında, burada iişlev işaretçisi için çözüldü int(*)(). Bu sadece basittir cout, ancak kullanıldığında ne tür kötü derleme / çalışma zamanı hatalarına neden olabileceğini hayal edin template.

Bu tür ifadelerden kaçınmalı auto ve uygun bir returntür (veya kontrollü decltype()) koymalısınız

Yukarıdaki örnek için doğru kullanım,

auto i = []() { return 0; }(); // and now i contains the result of calling the lambda