मैं देख रहा हूं कि पहले से ही बहुत से बढ़िया जवाब हैं। जिनमें से कुछ मैं दोहराता रहूंगा लेकिन कभी-कभी आप सिर्फ अपने शब्दों में ही बात करना चाहते हैं। मैं C ++ के कुछ उदाहरणों के साथ टिप्पणी करूंगा क्योंकि यही वह भाषा है जिसके साथ मेरी सबसे अधिक परिचितता है।
जो आवश्यक है वह कभी नासमझ नहीं है। अन्य भाषा सुविधाओं को व्यावहारिक बनाने के लिए टाइप इंट्रेंस आवश्यक है। C ++ में अप्रभावित प्रकारों का होना संभव है।
struct {
double x, y;
} p0 = { 0.0, 0.0 };
// there is no name for the type of p0
auto p1 = p0;
सी ++ 11 ने लंबोदा को जोड़ा जो कि अप्राप्य भी हैं।
auto sq = [](int x) {
return x * x;
};
// there is no name for the type of sq
टाइप इंस्पेक्शन भी टेम्पलेट को कम करता है।
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
लेकिन आपके प्रश्न थे "मैं क्यों, प्रोग्रामर, जब मैं कोड पढ़ता हूं, तो मेरे प्रकार के प्रकारों का पता लगाना चाहता हूं? क्या किसी के लिए यह पढ़ना ज्यादा तेजी से नहीं है कि यह सोचने के बजाय कि टाइप क्या है?"
प्रकार का अनुमान अतिरेक को दूर करता है। जब रीडिंग कोड की बात आती है तो कोड में अनावश्यक जानकारी होना कभी-कभी तेज और आसान हो सकता है, लेकिन अतिरेक उपयोगी जानकारी को ओवरडोज कर सकता है । उदाहरण के लिए:
std::vector<int> v;
std::vector<int>::iterator i = v.begin();
यह C ++ प्रोग्रामर के लिए मानक पुस्तकालय के साथ बहुत परिचित नहीं है कि यह पहचानने के लिए कि मैं एक पुनरावृत्ति है i = v.begin()जिससे स्पष्ट प्रकार की घोषणा सीमित मूल्य की है। इसकी उपस्थिति से यह उन विवरणों को अस्पष्ट करता है जो अधिक महत्वपूर्ण हैं (जैसे कि iवेक्टर की शुरुआत के लिए बिंदु)। @Amon द्वारा ठीक उत्तर महत्वपूर्ण विवरणों की ओवरशोडिंग का एक और बेहतर उदाहरण प्रदान करता है। इसके विपरीत प्रकार के प्रयोग से महत्वपूर्ण विवरणों को अधिक प्रमुखता मिलती है।
std::vector<int> v;
auto i = v.begin();
जबकि कोड पढ़ना महत्वपूर्ण है यह पर्याप्त नहीं है, कुछ बिंदु पर आपको पढ़ना बंद करना होगा और नया कोड लिखना शुरू करना होगा। कोड में अतिरेक कोड को धीमा और कठिन बनाता है। उदाहरण के लिए, कहें कि मेरे पास कोड का निम्नलिखित टुकड़ा है:
std::vector<int> v;
std::vector<int>::iterator i = v.begin();
इस मामले में कि मुझे कोड को डबल बदलने के लिए वेक्टर के मूल्य प्रकार को बदलने की आवश्यकता है:
std::vector<double> v;
std::vector<double>::iterator i = v.begin();
इस मामले में मुझे दो स्थानों पर कोड को संशोधित करना होगा। मूल कोड है:
std::vector<int> v;
auto i = v.begin();
और संशोधित कोड:
std::vector<double> v;
auto i = v.begin();
ध्यान दें कि मुझे अब केवल एक पंक्ति कोड बदलना होगा। इसे एक बड़े कार्यक्रम में शामिल करें और एक संपादक के साथ जितना हो सके उतने प्रकार के अनुमानों से परिवर्तनों को अधिक तेज़ी से बदल सकते हैं।
कोड में अतिरेक बग की संभावना बनाता है। किसी भी समय आपका कोड सूचना के दो टुकड़ों पर निर्भर होता है, जिसके समतुल्य होने पर गलती की संभावना होती है। उदाहरण के लिए, इस कथन में दो प्रकारों के बीच एक असंगतता है, जो शायद इरादा नहीं है:
int pi = 3.14159;
अतिरेक इरादे को कठिन बना देता है। कुछ मामलों में टाइप इंफ़ेक्शन को पढ़ना और समझना आसान हो सकता है क्योंकि यह स्पष्ट प्रकार के विनिर्देशन की तुलना में सरल है। कोड के टुकड़े पर विचार करें:
int y = sq(x);
मामले में है कि sq(x)रिटर्न एक intहै, यह नहीं स्पष्ट है कि क्या yएक है intक्योंकि यह की वापसी प्रकार है sq(x)या क्योंकि यह सूट बयान है कि उपयोग y। यदि मैं अन्य कोड को बदल देता हूं , जो sq(x)अब वापस नहीं आता है int, तो यह उस रेखा से अनिश्चित है कि क्या प्रकार को yअद्यतन किया जाना चाहिए। एक ही कोड के साथ विरोधाभास लेकिन प्रकार का प्रयोग
auto y = sq(x);
इसमें आशय स्पष्ट है, yउसी प्रकार का होना चाहिए जिस प्रकार से लौटाया गया है sq(x)। जब कोड रिटर्न प्रकार बदलता है sq(x), तो yस्वचालित रूप से मिलान करने के लिए परिवर्तन का प्रकार ।
सी ++ में एक दूसरा कारण है कि उपरोक्त उदाहरण सरल प्रकार के अनुमान के साथ सरल है, प्रकार का अनुमान इंजेक्शन प्रकार के रूपांतरण का परिचय नहीं दे सकता है। यदि वापसी का प्रकार sq(x)नहीं है int, तो संकलक चुपचाप एक अंतर्निहित रूपांतरण सम्मिलित करता है int। यदि रिटर्न प्रकार sq(x)एक प्रकार का जटिल प्रकार है जो परिभाषित करता है operator int(), तो यह छिपा हुआ फ़ंक्शन कॉल मनमाने ढंग से जटिल हो सकता है।