फंक्शन ओवरलोडिंग को हल करने में C ++ कंपाइलर की मदद करें

कुछ मामलों में, C ++ कंपाइलर एक उपयुक्त अतिभारित फ़ंक्शन का चयन नहीं कर सकते हैं, उदाहरण के लिए, ऐसी स्थिति में जो मानव दृष्टिकोण से स्पष्ट है - एक संकलन त्रुटि होती है:

void f(int i){} void f(string s){} vector<int> int_c = { 1, 2, 3, 4, 5 }; vector<string> string_c = { "Sic" ,"transit" ,"gloria" ,"mundi" }; for_each(begin(int_c), end(int_c), f);//error C2672: "for_each":      

समस्या अंतिम पंक्ति में f के लिए मापदंडों की कमी है, जिस पर कंपाइलर अधिभार को हल कर सकता है। यह तथ्य कि बहुत विशिष्ट प्रकार के पुनरावृत्तियों को for_each पैरामीटर पास किया जाता है, संकलक के लिए कोई मायने नहीं रखता है।

आप समस्या को हल करने के कई "ललाट" तरीके दे सकते हैं:

1) वांछित प्रकार के फ़ंक्शन पॉइंटर को कास्ट करने के लिए static_cast <> () का उपयोग करना।

हम सूचक को f (v i) शून्य करने के लिए कास्ट करते हैं:

 std::for_each(begin(int_c), end(int_c), static_cast<void (*)(int)>(&f)); 

हम सूचक को शून्य (स्ट्रिंग i) शून्य करने के लिए ले गए:

 std::for_each(begin(string_c), end(string_c), static_cast<void (*)(string)>(&f)); 

2) कार्यों और उनके उपयोग के लिए संकेत की परिभाषा।

हम शून्य f (int i) का उपयोग करते हैं:

  void (*fp_int)(int) = &f; for_each(begin(int_c), end(int_c), fp_int); 

हम शून्य f (स्ट्रिंग i) का उपयोग करते हैं:

 void (*fp_string)(string) = &f; for_each(begin(string_c), end(string_c), fp_string); 

3) for_each टेम्पलेट फ़ंक्शन के लिए स्पष्ट विशेषज्ञता बनाना:

हम शून्य f (int i) का उपयोग करते हैं:

 std::for_each<vector<int>::const_iterator, void(*)(int) >(int_c.begin(), int_c.end(), f); 

हम शून्य f (स्ट्रिंग i) का उपयोग करते हैं:

 std::for_each<vector<string>::const_iterator, void(*)(string) >(string_c.begin(), string_c.end(), f); 

या अधिक कॉम्पैक्ट:

 std::for_each<decltype(int_c.begin()), void(*)(int) >(int_c.begin(), int_c.end(), f); std::for_each<decltype(string_c.begin()), void(*)(string) >(string_c.begin(), string_c.end(), f); 

ऊपर प्रस्तावित तरीके सार्वभौमिक नहीं हैं और कॉलिंग पक्ष पर अतिरिक्त कोड विकसित करने की आवश्यकता है। सबसे अच्छा विचार यह है कि फ़ंक्शन f के ऊपर एक पतला शेल बनाया जाए जो फ़ंक्शन f के मापदंडों को लेता है और परिवर्तनों के बिना उन्हें पास करता है।

संभावनाओं पर विचार करना भी आवश्यक है:

• फ़ंक्शन के मापदंडों की अनिश्चित संख्या की उपस्थिति च,
• फ़ंक्शन के रिटर्न मान की उपस्थिति,
• संदर्भ से गुजरने वाले पैरामीटर,
• सीवी पैरामीटर क्वालिफायर का अस्तित्व,
• समारोह में अपवाद एफ।

चरण दर चरण हम ऐसे शेल के निर्माण का विश्लेषण करेंगे। लैम्ब्डा फ़ंक्शन एक अच्छी नींव है। संकलक द्वारा C ++ 11 मानक के समर्थन के साथ, इसे निम्नानुसार लागू किया जा सकता है:

 for_each(begin(int_c), end(int_c), [](int a) { return f(a); }); for_each(begin(string_c), end(string_c), [](string a) { return f(a); }); 

या घोषणापत्र () का उपयोग कर:

 for_each(begin(int_c), end(int_c), [](decltype(*int_c.begin()) a) { return f(a); }); for_each(begin(string_c), end(string_c), [](decltype(*string_c.begin()) a) { return f(a); }); 

संकलक द्वारा C ++ 14 मानक के समर्थन के साथ, हमारे पास बहुरूपी लैंबडा के लिए निम्नलिखित समाधान है:

 auto l = [](auto a) { return f(a); }; for_each(begin(int_c), end(int_c), l); for_each(begin(string_c), end(string_c), l); 

तो, हम फंक्शन पैरामीटर को f से लैम्बडा के पैरामीटर के रूप में पास करते हैं, और फिर हम इस पैरामीटर के साथ f को कॉल करते हैं। लेकिन एक समस्या है: हम पहले से नहीं जानते हैं - क्या फ़ंक्शन एफ मान या संदर्भ के पैरामीटर हैं? इसलिए, आपको सही गियर का उपयोग करना चाहिए।

 auto l = [](auto&& a) { return f(std::forward<decltype(a)>(a)); }; for_each(begin(int_c), end(int_c), l); for_each(begin(string_c), end(string_c), l); 

परफेक्ट ट्रांसमिशन (परफेक्ट फॉरवर्डिंग) के विषय पर मेयर्स [1] में पाया जा सकता है। उसी सामग्री की प्रस्तुति का एक और अधिक समझने योग्य (मेरे लिए, वैसे) संस्करण लेख [2] में पाया जा सकता है, जिसका अनुवाद हैबे [3] पर है।

फ़ंक्शन पैरामीटर की अनिश्चित संख्या के लिए, हम लंबो मापदंडों को वैर सक्षम और कॉल std के रूप में इंगित करते हैं :: f के लिए पारित प्रत्येक पैरामीटर के लिए आगे।

  auto l = [](auto&&... a) { return f(std::forward<decltype(a)>(a)...); }; 

हम संकलक समय निर्दिष्ट करते हैं नोइसेप्ट को निर्दिष्ट करते हैं [4] और नॉइसेप्ट ऑपरेटर को [5] कंपाइलर को इंगित करते हैं कि फ़ंक्शन f अपवाद को फेंक देगा [6]।

  auto l = [](auto&&... a) \ noexcept(noexcept(f(std::forward<decltype(a)>(a)...)))\ { return f(std::forward<decltype(a)>(a)...); }; 

निर्मित लंबोदर के लिए रिटर्न वैल्यू टाइप का आउटपुट जोड़ें।

  auto l = [](auto&&... a) \ noexcept(noexcept(f(std::forward<decltype(a)>(a)...)))\ -> decltype(f(std::forward<decltype(a)>(a)...))\ { return f(std::forward<decltype(a)>(a)...); }; 

यदि ट्रिपल कोड पुनरावृत्ति कष्टप्रद है और हम मैक्रोज़ का उपयोग करने में संकोच नहीं करते हैं - तो आप कॉलिंग पक्ष पर आकार कम कर सकते हैं।

 #define LIFT(foo) \ [](auto&&... x) \ noexcept(noexcept(foo(std::forward<decltype(x)>(x)...))) \ -> decltype(foo(std::forward<decltype(x)>(x)...)) \ { return foo(std::forward<decltype(x)>(x)...); } 

नतीजतन, हमारे पास एक शेल है जो कंपाइलर को एक अधिभारित फ़ंक्शन को हल करने में मदद करता है।

 for_each(begin(int_c), end(int_c), LIFT(f)); for_each(begin(string_c), end(string_c), LIFT(f)); 

[१] एस। मेयर्स "प्रभावी आधुनिक सी ++" आइटम २४: रूवल संदर्भों से सार्वभौमिक संदर्भों का भेद करें।
[२] eli.thegreenplace.net/2014/perfect-forwarding-and-universal-references-in-c
[३] habr.com/en/post/242639
[४] en.cppreference.com/w/cpp/language/noexcept_spec
[५] en.cppreference.com/w/cpp/language/noexcept
[६] habr.com/en/post/164221
[[] Www.fluentcpp.com/2017/08/01/overloaded-functions-stl
[[] Www.youtube.com/watch?v=I3T4lePH-yA