शुभ दोपहर, प्रिय पाठक!

यह लेख अमूर्त लेखों की एक श्रृंखला में दूसरा है जिसे मैं स्कॉट मेयर्स की सबसे अधिक बिकने वाली पुस्तक, प्रभावी और आधुनिक सी ++ के माध्यम से पढ़ूंगा। इन लेखों में से प्रत्येक में विशेष रूप से github.com पर एक परियोजना में एक अलग निर्देशिका होगी जिसका उपयोग हम आज पढ़ रहे हैं के जीवंत उदाहरणों के साथ करेंगे।

यह आलेख पिछले आलेख से प्रकार के निष्कासन नियमों को पूरक करता है और एक प्रकार और एक फ़ंक्शन वाले तर्कों के लिए टेम्पलेट प्रकार के निष्कर्ष के कुछ पहलुओं पर चर्चा करता है।

सरणी के लिए पैटर्न प्रकार का निष्कर्ष

C ++ कंपाइलर के पास ऐसी संपत्ति होती है जो घोषित ऐरे हमेशा, जब एक लिंक के रूप में घोषित पैरामीटर के साथ टेम्प्लेट फ़ंक्शन में पास किया जाता है, तो हमेशा एक पॉइंटर को संग्रहित प्रकार में बदल दिया जाता है और इसके विपरीत, यदि पैरामीटर को लिंक के रूप में घोषित किया जाता है, तो ऐसा रूपांतरण नहीं किया जाता है।

टेम्पलेट कार्य:

शुरू करने के लिए, मैं टेम्पलेट प्रकारों का कोड दूंगा, जो प्रतिष्ठित प्रकारों को घटाते हैं, और फिर व्युत्पत्ति प्रक्रिया स्वयं:

template<typename T> void paramDeductInfo(T param, const char *initType) { std::cout << initType << " -> (T param) -> " << type_id_with_cvr<T>().pretty_name() << std::endl; }; template<typename T> void refParamDeductInfo(T &param, const char *initType) { std::cout << initType << " -> (T &param) -> " << type_id_with_cvr<T>().pretty_name() << std::endl; }; 

प्रकार का आविष्कार:

 cli::printCaption("TYPE DEDUCTION FOR ARRAY OF CHAR"); char charSeq[] = "Hi everyone!"; paramDeductInfo(charSeq, "char []"); refParamDeductInfo(charSeq, "char []"); cli::printCaption("TYPE DEDUCTION FOR ARRAY OF INT"); int intSeq[] = {1, 2, 3}; paramDeductInfo(intSeq, "int []"); refParamDeductInfo(intSeq, "int []"); cli::printCaption("TYPE DEDUCTION FOR ARRAY OF CLASS A"); class A { } const classASeq[] = {A(), A(), A()}; paramDeductInfo(classASeq, "class A[]"); refParamDeductInfo(classASeq, "class A[]"); 

निम्नलिखित छद्म कोड इन निर्देशों के कंसोल के आउटपुट को दर्शाता है:

 ************************************************************************************************************************ TYPE DEDUCTION FOR ARRAY OF CHAR ************************************************************************************************************************ char [] -> (T param) -> char* char [] -> (T &param) -> char [13] ************************************************************************************************************************ TYPE DEDUCTION FOR ARRAY OF INT ************************************************************************************************************************ int [] -> (T param) -> int* int [] -> (T &param) -> int [3] ************************************************************************************************************************ TYPE DEDUCTION FOR ARRAY OF CLASS A ************************************************************************************************************************ class A[] -> (T param) -> main::A const* class A[] -> (T &param) -> main::A const [3] 

उदाहरण 1 - संकलन-समय सरणी की लंबाई का विश्लेषण

इसके अलावा, सरणी का आउटपुट प्रकार इसके आकार के बारे में जानकारी संग्रहीत करता है, जिसका उपयोग टेम्पलेट फ़ंक्शन में संकलन के दौरान सरणी के आकार में हेरफेर करने या अधिक कुशल कोड उत्पन्न करने के लिए किया जा सकता है।

मैंने इस सुविधा का उपयोग प्रिंटकैपियन फंक्शन में कमांड लाइन पर प्रदर्शित हेडर की लंबाई को संकलन के समय सीमित करने के लिए किया था। एक तिपहिया, लेकिन अच्छा है।

 namespace cli { template<typename T, std::size_t N> constexpr void printCaption(T (&capValue)[N]) { static_assert(N <= 121, "caption length should be less than 120"); std::cout << std::endl << "*******************************************************************************" << std::endl << capValue << std::endl << "*******************************************************************************" << std::endl << std::endl; }; } 

अगर हम स्पष्ट रूप से अनुचित हेडर लगाते हैं तो एक त्रुटि होगी।

 cli::printCaption("123456789 123456789 123456789 123456789 123456789 123456789 123456789" "123456789 123456789 123456789 123456789 123456789 !"); 

और यहाँ आप कृपया, ठीक है, यह अद्भुत नहीं है?

 /...sources/cli.h:12:3: error: static assertion failed: caption length should be less than 120 static_assert(N <= 121, "caption length should be less than 120"); ^~~~~~~~~~~~~ 

उदाहरण 2 - स्मृति में एक सरणी पर foreach

मुझे लगता है कि यहां एक और ऐसा दृष्टिकोण है जो उपयोगी लग सकता है यदि हमारे पास संकलन-समय में एक सरणी आकार है, तो इसका उपयोग ऐसे सरणी पर लूप को व्यवस्थित करने के लिए क्यों नहीं किया जाता है?

 template<typename T, size_t N, typename F> void forEachOnAnArray(T (&inmemArray)[N], F &callback) { for (int i = 0; i < N; ++i) callback(inmemArray[i]); }; 

इस फ़ंक्शन का उपयोग निम्नानुसार है:

  auto printInt = [](int value) { std::cout << " " << value; }; forEachOnAnArray(intSeq, printInt); 

सामान्य तौर पर, इस सुविधा का उपयोग करना सरणी के आकार को बाहर निकालने तक सीमित नहीं है।

एक समारोह के लिए प्रकार का अनुमान

मेयर्स फ़ंक्शन के लिए प्रकार के निष्कर्ष की बात संक्षिप्त है। वह बिल्कुल उल्लेख करता है कि वे उसी तरह से एक संकेतक के लिए कम हो जाते हैं जैसे कि सरणियों के लिए, जब टेम्पलेट फ़ंक्शन का पैरामीटर जिसके द्वारा हमारे फ़ंक्शन प्रकार को प्रदर्शित किया जाना है, लिंक के रूप में घोषित नहीं किया जाता है।

उन्हें शायद कार्यों के लिए कुछ प्रकार के टेम्पलेट रैपर के बारे में बात करनी चाहिए थी, लेकिन मुझे लगता है कि कुशल और आधुनिक सी ++ के सवाल से परे है।

हम, मेरे प्रिय पाठक, इस मुद्दे पर अवश्य लौटेंगे!

धन्यवाद और आपका दिन शुभ हो !!