C ++ 'da otomatik değişkenleri bildirmenin bir dezavantajı var mı?

Görünüşe göre auto, birçok yeni dili takip eden C ++ 11'e eklenmesi oldukça önemli bir özellikti. Python gibi bir dilde olduğu gibi, herhangi bir açık değişken bildirimi görmedim (Python standartlarını kullanarak mümkün olup olmadığından emin değilim).

autoDeğişkenleri açıkça belirtmek yerine bildirmek için kullanmanın bir dezavantajı var mı ?

Sadece sakıncaları sordunuz, bu yüzden bunlardan bazılarını vurguluyorum. İyi kullanıldığında autoçeşitli avantajları da vardır. Dezavantajları kötüye kullanım kolaylığı ve kodun istenmeyen şekilde davranma potansiyelinin artmasından kaynaklanmaktadır.

Ana dezavantajı, kullanarak auto, yaratılan nesnenin türünü bilmemenizdir. Programcının derleyicinin bir türü çıkarmasını bekleyebileceği durumlar da vardır, ancak derleyici başka birini kesin olarak çıkarır.

Gibi bir beyan verildi

auto result = CallSomeFunction(x,y,z);

ne tür resultolduğu konusunda bilginiz olmayabilir . Bir olabilir int. Bir işaretçi olabilir. Başka bir şey olabilir. Bunların hepsi farklı operasyonları desteklemektedir. Kodu, gibi küçük bir değişiklikle önemli ölçüde değiştirebilirsiniz.

auto result = CallSomeFunction(a,y,z);

çünkü CallSomeFunction()sonuç türü için hangi aşırı yüklenmelere bağlı olarak tamamen farklı olabilir ve bu nedenle sonraki kodlar amaçlanandan tamamen farklı olabilir. Aniden daha sonraki kodda hata mesajlarını tetikleyebilirsiniz (örneğin, daha sonra int, artık bir şey değiştirmeye çalışmak, şu anda olan bir şeyi değiştirmeye çalışmak const). Daha sinsi değişiklik, değişikliğin derleyiciyi geçtiği yerdir, ancak sonraki kod farklı ve bilinmeyen - muhtemelen buggy - şekilde davranır.

Bu nedenle, bazı değişkenlerin türü hakkında net bilgi sahibi olmamak, kodun amaçlandığı şekilde çalıştığı iddiasını titizlikle haklı kılar. Bu, yüksek kritiklikteki (örneğin güvenlik açısından kritik veya görev açısından kritik) alanlarda "amaca uygunluk" iddialarını haklı çıkarmak için daha fazla çaba anlamına gelir.

Diğer, daha yaygın bir dezavantaj, bir programcının auto, kodun ne yaptığını düşünmek ve doğru yapmak için çalışmak yerine, kodu derlemeye zorlamak için künt bir araç olarak kullanması cazibesidir .

Bu autotam olarak ilkeli bir dezavantaj değil , ama pratikte bazıları için bir sorun gibi görünüyor. Temel olarak, bazı insanlar ya: a) autotipler için bir kurtarıcı olarak davranırlar ve kullanırken beyinlerini autokapatırlar veya b) her zaman değer türlerine neden olanları unuturlar . Bu insanların böyle şeyler yapmasına neden olur:

auto x = my_obj.method_that_returns_reference();

Hata! Bir nesneyi derinden kopyaladık. Genellikle bir hata ya da performans başarısız olur. Sonra başka şekilde de sallayabilirsiniz:

const auto& stuff = *func_that_returns_unique_ptr();

Şimdi sarkan bir referans alıyorsunuz. Bu sorunlardan hiç kaynaklanmıyor auto, bu yüzden onlara karşı meşru argümanlar olduğunu düşünmüyorum. Ama autobaşlangıçta listelediğim nedenlerle, bu sorunu (kişisel deneyimimden) daha yaygın yapıyor gibi görünüyor .

İnsanların işbölümünü ayarlayabilmeleri ve anlayabilmeleri için zaman verildiğini düşünüyorum: autoaltta yatan türü çıkarır, ancak yine de referanslık ve sabitlik hakkında düşünmek istersiniz. Ama biraz zaman alıyor.

Diğer cevaplar, "bir değişkenin türünün ne olduğunu gerçekten bilmiyorsunuz" gibi dezavantajlardan bahsediyor. Bunun büyük ölçüde koddaki özensiz adlandırma kuralıyla ilgili olduğunu söyleyebilirim. Arayüzleriniz açıkça adlandırılmışsa, tam türün ne olduğunu önemsemeniz gerekmez . Tabii, auto result = callSomeFunction(a, b);sana fazla bir şey söylemiyor. Ancak , tam türünün ne olduğunu umursamadan auto valid = isValid(xmlFile, schema);kullanmanız için yeterli olduğunu söyler valid. Sonuçta, sadece if (callSomeFunction(a, b)), türü de bilmezdiniz. Diğer alt ifade geçici nesneleri için de aynı şey geçerlidir. Bu yüzden bunun gerçek bir dezavantajı olduğunu düşünmüyorum auto.

Birincil dezavantajı, bazen, tam dönüş türünün çalışmak istediğiniz şey olmadığıdır . Aslında, gerçek dönüş türü bazen bir uygulama / optimizasyon ayrıntısı olarak "mantıksal" dönüş türünden farklıdır. İfade şablonları buna en iyi örnektir. Diyelim ki buna sahibiz:

SomeType operator* (const Matrix &lhs, const Vector &rhs);

Mantıken, biz beklenebilir SomeTypeolması Vectorve biz kesinlikle bizim kodunda gibi bunu tedavi etmek istiyorum. Ancak, optimizasyon amacıyla kullandığımız cebir kütüphanesinin ifade şablonlarını uygulaması mümkündür ve gerçek dönüş türü şöyledir:

MultExpression<Matrix, Vector> operator* (const Matrix &lhs, const Vector &rhs);

Şimdi, sorun büyük MultExpression<Matrix, Vector>olasılıkla a const Matrix&ve const Vector&dahili olarak depolanacak ; Vectortam ifadesinin bitiminden önce a'ya dönüşmesini bekler . Bu kod varsa, her şey yolunda:

extern Matrix a, b, c;
extern Vector v;

void compute()
{
  Vector res = a * (b * (c * v));
  // do something with res
}

Ancak, autoburada kullansaydık , başımız belaya girebilirdi:

void compute()
{
  auto res = a * (b * (c * v));
  // Oops! Now `res` is referring to temporaries (such as (c * v)) which no longer exist
}

Sakıncaları biri bazen beyan edemezler const_iteratorile auto. Bu sorudan alınan kodun bu örneğinde sıradan (const olmayan) yineleyici alacaksınız :

map<string,int> usa;
//...init usa
auto city_it = usa.find("New York");

Kodunuzu okumak biraz daha zor veya sıkıcı hale getirir. Böyle bir şey düşünün:

auto output = doSomethingWithData(variables);

Şimdi, çıktı türünü bulmak için doSomethingWithDataişlevin imzasını izlemeniz gerekir .

Bu geliştirici gibi nefret ediyorum auto. Ya da daha doğrusu, insanların nasıl kötüye kullanıldığından nefret ediyorum auto.

Yazmayı azaltmak için değilauto , genel kod yazmanıza yardımcı olmak için (güçlü) görüşüm . C ++, geliştirme süresini en aza indirmek için değil , sağlam kod yazmanıza izin veren bir dildir . Bu, C ++ 'ın birçok özelliğinden oldukça açıktır, ancak maalesef bu gibi yeni olanlardan birkaçı, yazarak yanıltıcı insanları yazarak tembelleşmeleri gerektiğini düşünmeye indirgiyor.

auto

Önceki autogünlerde insanlar typedefs'yi kullandı , bu harikaydı çünkü typedef kütüphane tasarımcısı dönüş türünün ne olması gerektiğini anlamanıza yardımcı oldu, böylece kütüphane beklendiği gibi çalışıyor. Kullandığınızda auto, bu denetimi sınıfın tasarımcısından alırsınız ve bunun yerine derleyiciden türün ne olması gerektiğini anlamasını istersiniz , bu da araç kutusundan en güçlü C ++ araçlarından birini kaldırır ve kodlarını kırma riski taşır .

Kullanmak Genellikle, autoçünkü olması gerektiği kodunuzu için çalışan herhangi makul türü , değil bunu birlikte çalışması gerektiğini türünü yazmak için sadece çok tembel çünkü. autoTembellik için bir araç olarak kullanırsanız , o zaman ne olur, sonunda programınıza, genellikle kullandığınız için gerçekleşmeyen örtük dönüşümlerin neden olduğu ince hatalar uygulamaya başlamanızdır auto.

Ne yazık ki, bu hataların kısa bir örnekte gösterilmesi zordur, çünkü kısalığı onları bir kullanıcı projesinde ortaya çıkan gerçek örneklerden daha az ikna edici hale getirir - ancak, belirli örtük dönüşümlerin alınmasını bekleyen şablon ağırlıklı kodda kolayca ortaya çıkar yer.

Bir örnek istiyorsanız, burada bir tane var . Bununla birlikte, küçük bir not: kodu atlayıp eleştirmeye başlamadan önce: bu tür örtülü dönüşümler etrafında birçok tanınmış ve olgun kütüphanenin geliştirildiğini ve imkansız değilse zor olabilecek sorunları çözdükleri için orada olduklarını unutmayın. başka türlü çözmek. Eleştirmeden önce daha iyi bir çözüm bulmaya çalışın .

autokendi başına dezavantajları yoktur ve ben (el-dalgalı) yeni kod her yerde kullanmak için savunmak. Kodunuzun sürekli yazımını ve sessiz dilimlemeden kaçınmasını sağlar. (Eğer Btüretirse Ave Aaniden dönen bir işlev dönerse B, autodönüş değerini saklaması beklendiği gibi davranır)

Bununla birlikte, C ++ 11 öncesi eski kod, açıkça yazılan değişkenlerin kullanımından kaynaklanan örtük dönüşümlere dayanabilir. Açıkça yazılan bir değişkeni autodeğiştirmek, kod davranışını değiştirebilir , bu nedenle dikkatli olmanız daha iyi olur.

Anahtar kelime autotürü dönüş değerinden çıkarır. Bu nedenle, bir Python nesnesiyle eşdeğer değildir, örn.

# Python
a
a = 10       # OK
a = "10"     # OK
a = ClassA() # OK

// C++
auto a;      // Unable to deduce variable a
auto a = 10; // OK
a = "10";    // Value of const char* can't be assigned to int
a = ClassA{} // Value of ClassA can't be assigned to int
a = 10.0;    // OK, implicit casting warning

Yana autoderleme sırasında çıkarılır, bu çalışma zamanı olursa olsun herhangi bir dezavantajı var olmayacaktır.

Bana şimdiye kadar burada kimsenin bahsetmediği, ama kendisi için bir cevap vermeye değer.

(Herkes bunu bilmeli olsa bile C != C++) C ile yazılmış kod C ++ kodu için bir taban sağlamak üzere kolayca tasarlanabildiğinden ve bu nedenle C ++ uyumlu olmak için fazla çaba harcamadan tasarlanabildiğinden, bu tasarım için bir gereklilik olabilir.

Bazı iyi tanımlanmış yapıları Cgeçersiz C++ve tersi bazı kuralları biliyorum . Ancak bu sadece yürütülebilir dosyalar ile sonuçlanır ve çoğu zaman çökmelere neden olan garip döngülerle fark edilen (veya fark edilmeden kalabilir, ancak burada önemli olmayan) bilinen UB cümlesi geçerlidir.

Ama autoilk kez ¹ Bu değişiklikler!

Daha autoönce depolama sınıfı belirleyicisi olarak kullandığınızı ve kodu aktardığınızı düşünün . (Kullanılma biçimine bağlı olarak) zorunlu olarak “kırılmaya”; aslında programın davranışını sessizce değiştirebilir.

Bu akılda tutulması gereken bir şey.

¹ _{En azından ilk kez farkındayım.}

Düşünebilmemin bir nedeni, geri dönen sınıfı zorlama fırsatını kaybetmenizdir. İşleviniz veya yönteminiz uzun bir 64 bit döndürdüyse ve yalnızca 32 imzasız int istediyseniz, bunu kontrol etme fırsatını kaybedersiniz.

Bu cevapta tarif ettiğim autogibi bazen istemediğiniz korkak durumlarla sonuçlanabilir. auto&Sadece autobir işaretçi türü oluşturabilirsiniz yaparken açıkça bir referans türü olduğunu söylemek gerekir . Bu, belirleyiciyi hep birlikte atlayarak karışıklığa neden olabilir ve gerçek bir referans yerine referansın bir kopyasına neden olabilir.

Diğer rahatsız edici bir örnek:

for (auto i = 0; i < s.size(); ++i)

imzalı bir int olduğu için bir uyarı ( comparison between signed and unsigned integer expressions [-Wsign-compare]) oluşturur i. Bundan kaçınmak için örn.

for (auto i = 0U; i < s.size(); ++i)

veya belki de daha iyisi:

for (auto i = 0ULL; i < s.size(); ++i)

autoOkuyucunun türünü kolayca ve açık bir şekilde düşürebileceği veya türünün bir yorumu veya gerçek türü çıkaran bir adla iyi belgelendirildiği yerelleştirilmiş bir bağlamda kullanıldığında iyi olduğunu düşünüyorum . Nasıl çalıştığını anlamayanlar, onu yanlış şekillerde kullanabilirler, örneğin yerine templateveya benzeri gibi. Bence bazı iyi ve kötü kullanım durumları.

void test (const int & a)
{
    // b is not const
    // b is not a reference

    auto b = a;

    // b type is decided by the compiler based on value of a
    // a is int
}

İyi Kullanımlar

yineleyiciler

std::vector<boost::tuple<ClassWithLongName1,std::vector<ClassWithLongName2>,int> v();

..

std::vector<boost::tuple<ClassWithLongName1,std::vector<ClassWithLongName2>,int>::iterator it = v.begin();

// VS

auto vi = v.begin();

İşlev İşaretçileri

int test (ClassWithLongName1 a, ClassWithLongName2 b, int c)
{
    ..
}

..

int (*fp)(ClassWithLongName1, ClassWithLongName2, int) = test;

// VS

auto *f = test;

Kötü Kullanımlar

Veri akışı

auto input = "";

..

auto output = test(input);

İşlev İmzası

auto test (auto a, auto b, auto c)
{
    ..
}

Önemsiz Durumlar

for(auto i = 0; i < 100; i++)
{
    ..
}

Kimsenin bundan bahsetmediğine şaşırdım, ancak bir şeyin faktöriyelini hesapladığınızı varsayalım:

#include <iostream>
using namespace std;

int main() {
    auto n = 40;
    auto factorial = 1;

    for(int i = 1; i <=n; ++i)
    {
        factorial *= i;
    }

    cout << "Factorial of " << n << " = " << factorial <<endl;   
    cout << "Size of factorial: " << sizeof(factorial) << endl; 
    return 0;
}

Bu kod şu çıktıyı verecektir:

Factorial of 40 = 0
Size of factorial: 4

Bu kesinlikle beklenen sonuç değildi. Bu auto, değişken faktörünün türüne intatandığı gibi çıkarıldığı için oldu 1.