Görüyorum ki zaten çok sayıda iyi cevap var. Bazıları tekrarlayacağım ama bazen sadece kendi sözlerine bir şeyler koymak istiyorsun. C ++ 'dan bazı örnekler ile yorum yapacağım çünkü en çok aşina olduğum dil bu.
Gerekli olan asla akıllıca olmaz. Diğer dil özelliklerini pratik yapmak için tür çıkarımı gereklidir. C ++ 'da unutulmaz tiplere sahip olmak mümkündür.
struct {
double x, y;
} p0 = { 0.0, 0.0 };
// there is no name for the type of p0
auto p1 = p0;
C ++ 11 de unutulmaz olan lambda ekler.
auto sq = [](int x) {
return x * x;
};
// there is no name for the type of sq
Yazım çıkarımı ayrıca şablonları da destekler.
template <class x_t>
auto sq(x_t const& x)
{
return x * x;
}
// x_t is not known until it is inferred from an expression
sq(2); // x_t is int
sq(2.0); // x_t is double
Ancak sorularınız "neden programcı, kodu okuduğumda değişkenlerimin türünü anlamak isterim? Bir kimsenin sadece türün ne tür olduğunu düşünmekten daha hızlı bir şekilde türünü okuması daha hızlı değil mi?" İdi.
Tür çıkarımı fazlalığı giderir. Kod okumaya gelince, kodda yedekli bilgiye sahip olmak bazen daha hızlı ve daha kolay olabilir, ancak fazlalık yararlı bilgilerin gölgesinde kalabilir . Örneğin:
std::vector<int> v;
std::vector<int>::iterator i = v.begin();
i = v.begin()Açık bir tür bildiriminin sınırlı değerli olması için i'nin bir yineleyici olduğunu tanımlamak için bir C ++ programcısının standart kütüphanesine fazla aşina gelmez . Varlığında daha önemli olan ayrıntıları gizler (örneğin i, vektörün başlangıcına işaret eder). @Amon'un ince cevabı, önemli detayları gölgeleyen ayrıntılı bir örnek teşkil eder. Aksine, tür çıkarımı kullanılması, önemli ayrıntılara daha fazla önem verir.
std::vector<int> v;
auto i = v.begin();
Kod okumak önemli olsa da, bu yeterli değildir, bir noktada okumayı bırakmanız ve yeni kod yazmaya başlamanız gerekecektir. Koddaki artıklık, kod değiştirmeyi yavaşlatır ve zorlaştırır. Örneğin, aşağıdaki kod parçasına sahip olduğumu varsayalım:
std::vector<int> v;
std::vector<int>::iterator i = v.begin();
Kodu iki katına çıkarmak için vektörün değer türünü değiştirmem gerekiyorsa:
std::vector<double> v;
std::vector<double>::iterator i = v.begin();
Bu durumda kodu iki yerde değiştirmem gerekiyor. Orijinal kodun bulunduğu tür çıkarımına sahip kontrast:
std::vector<int> v;
auto i = v.begin();
Ve değiştirilen kod:
std::vector<double> v;
auto i = v.begin();
Şimdi sadece bir kod satırını değiştirmem gerektiğine dikkat edin. Bunu ekstrapolate edip büyük bir programa yazın ve yazım çıkarımı, yazım değişikliklerini bir editörle yapabileceğinizden çok daha hızlı bir şekilde yayınlayabilir.
Koddaki fazlalık, hata olasılığını yaratır. Kodunuz her zaman eşdeğer tutulan iki bilgi parçasına bağlı olduğunda, bir hata olasılığı vardır. Örneğin, bu açıklamada muhtemelen amaçlanmayan iki tür arasında bir tutarsızlık var:
int pi = 3.14159;
Artıklık, niyeti ayırt etmeyi zorlaştırır. Bazı durumlarda, tür çıkarımının okunması ve anlaşılması daha kolay olabilir çünkü açık tip özelliklerinden daha basittir. Kod parçasını göz önünde bulundurun:
int y = sq(x);
Durumda olduğunu sq(x)döndürür bir int, o olmadığı belli değildir ybir olan intbu dönüş türü olduğu için sq(x)ya da ifadeleri kullanan uygun çünkü y. Diğer kodu sq(x)artık döndürmeyecek şekilde değiştirirsem int, türünün ygüncellenmesi gerekip gerekmediği yalnızca bu satırdan belirsizdir . Aynı kodla fakat tip çıkarımını kullanarak kontrast:
auto y = sq(x);
Buradaki amaç açıktır, ygeri döndürdüğü ile aynı tipte olmalıdır sq(x). Kod dönüş türünü değiştirdiğinde, otomatik olarak eşleşecek değişikliklerin sq(x)türü y.
C ++ 'da yukarıdaki örneğin tip çıkarımı ile daha basit olmasının ikinci bir nedeni var, tip çıkarımı örtük tip dönüşümü sağlayamıyor. Dönüş türü sq(x)değilse int, sessiz bir şekilde derleyici ile örtülü bir dönüşüm ekleyin int. Dönüş türü, sq(x)tanımlayan bir tip karmaşık tipse operator int(), bu gizli işlev çağrısı isteğe bağlı olarak karmaşık olabilir.