C ++ में नेस्टेड फ़ंक्शंस

समुदाय को बधाई!

मुझे C ++ में कुछ ऐसा करने का अवसर मिला, जो फंक्शन्स के अंदर फंक्शन्स घोषित करने के समान है। यह इस तरह दिखता है:

#include <iostream> int main() { inline_function(std::string s) { std::cout << "Hello, " << s << "!\n"; } with_name(make_hello); make_hello("Vasiliy Pupkin!"); return 0; } 

उपरोक्त उदाहरण में, मुख्य विधि के अंदर, एक नेस्टेड "विधि" नाम make_hello के साथ बनाई गई है और फिर पैरामीटर "वासिली पुपकिन" के साथ बुलाया जाता है। बेशक, Hello, Vasiliy Pupkin! ।

दुर्भाग्य से, मैं नाम को ऊपर नहीं खींच सका।



यह, निश्चित रूप से, मैक्रोज़ पर किया जाता है।

मैक्रोज़ के बिना उसी के उदाहरण

C ++ में, अभी भी कोई नेस्टेड फ़ंक्शन नहीं हैं, इसलिए हमें कुछ और के साथ उनके सिंटैक्स का अनुकरण करना होगा। इसलिए, हम अपने आप से एक और सवाल पूछते हैं: क्या वास्तव में एक फ़ंक्शन के समान दिखता है, लेकिन फ़ंक्शन नहीं?

दो उत्तर हैं: सबसे पहले, किसी ऑब्जेक्ट को "शून्य में" बनाए बिना कक्षा के कंस्ट्रक्टर को कॉल करना:

 #include <stdio.h> int main() { //        class inline_function { public: //          inline_function() { printf("Hello, hell!\n"); } }; //      inline_function(); return 0; } 

दुर्भाग्य से, दो महत्वपूर्ण "बट" हैं जो अभ्यास में दिए गए उदाहरण के उपयोग की अनुमति नहीं देते हैं:

1. हम प्रत्येक फ़ंक्शन कॉल के लिए एक नया ऑब्जेक्ट बनाते हैं, जो अच्छा नहीं है। खैर, मैं कई कॉल के लिए कैसे साइकिल चलाऊं? ऐसी चीज़ की घोषणा के तथ्य पर ओवरहेड लागत को सहन किया जा सकता है, लेकिन उपयोग पर नहीं।

2. कंपाइलर ऑप्टिमाइज़ेशन वाला विज़ुअल स्टूडियो बेकार के रूप में इनलाइन_फंक्शन () के निर्माण को काट देता है। संकलक का तर्क समझ में आता है (वैसे भी, कोई भी इस बनाई गई वस्तु का उपयोग नहीं करेगा, इसलिए इसे क्यों बनाएं?) लेकिन यह खतरनाक है।

हालांकि, अभी भी "ऑपरेटरों के पुनर्वितरण" नामक एक चीज है - और हम डबल ब्रैकेट्स को फिर से परिभाषित कर सकते हैं (स्मार्टली पुनर्परिभाषित ऑपरेटर () को "फ़न्क्टर" कहा जाता है, जैसे):

 #include <stdio.h> int main() { //        class inline_function_class { public: void operator()() { printf("Hello, world!\n"); } }; //       --   ! inline_function_class inline_function; //    inline_function(); return 0; } 

इस उदाहरण में, लगभग सब कुछ पहले से ही ठीक है, सिवाय इसके कि वर्ग को गुमनाम किया जा सकता है, ताकि आपको inline_function_class प्रकार का नाम inline_function_class आवश्यकता न inline_function_class

 #include <stdio.h> int main() { //        class { public: void operator()() { printf("Hello, world!\n"); } } inline_function; //       //    inline_function(); return 0; } 

राइटिंग मैक्रोज़

तो, लक्ष्य - सिद्धांत रूप में - हासिल किया गया है: हमारे पास एक तरीके के अंदर कोड के एक टुकड़े को अलग करने का एक तरीका है ताकि बाहरी दृश्यता क्षेत्र को खराब न करें। लेकिन एक माइनस है: दिए गए सभी उदाहरणों में - मेरे स्वाद के लिए - बहुत सारे अक्षर हैं। इसलिए, हम अपने कोड को तीन भागों में विभाजित करेंगे:

 #include <stdio.h> int main() { //        /**   --   ,   ,     : **/ class { public: void operator()(/*       */) { /**  -- ,  ,     **/ printf("Hello, world!\n"); /**   --    **/ } } inline_function; //       /** =============================== **/ //    inline_function(); return 0; } 

पहले और दूसरे हिस्से को दो मैक्रों में समेटा जा सकता है, जिससे उन्हें कुछ अच्छे नाम मिलेंगे। उदाहरण के लिए

 #define inline_function(params) \ class \ { \ public: void operator() (params)\ {\ #define with_name(value) \ }\ } value; #define with_params(...) __VA_ARGS__ //  -  ?  . 

इन मैक्रोज़ का उपयोग करते हुए, "नेस्टेड फ़ंक्शन" के कोड को उपस्थिति से बहुत सरल किया जाता है (हालांकि यह सी स्टाइल में नहीं दिखता है):

 int main() { inline_function(char * name) { printf("Hello, %s!\n",name); } with_name(hello) hello("Pupkin"); } 

दुर्भाग्य से, सब कुछ गलत हो जाता है यदि आप फ़ंक्शन के लिए एक पैरामीटर नहीं, बल्कि कम से कम दो सेट करने का प्रयास करते हैं। इस मामले में, कंपाइलर दुर्घटनाग्रस्त हो जाता है, वे कहते हैं, इनलाइन_फंक्शन मैक्रो में केवल एक पैरामीटर और बास्टा है। समस्या को __VA_ARGS__ मैक्रो का उपयोग करके हल किया जा सकता है (जो, हालांकि यह मानक का हिस्सा नहीं है, वास्तव में उपयोग किए गए कंपाइलरों द्वारा समर्थित है)।

थोड़ा और जटिल, लेकिन अभी भी स्वीकार्य, दो मापदंडों के साथ कार्य दिखेगा:

 int main() { inline_function (with_params(int a, int b)) { printf("%d+%d=%d\n",a,b,a+b); } with_name(plus); plus(2,2); } 

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

पीएस वास्तव में, नेस्टेड कक्षाएं बनाने की तकनीक दुनिया के रूप में पुरानी है, और मैं, निश्चित रूप से, कुछ भी नया नहीं खोज पाया। फिर भी, मुझे ऐसा लगता है कि इस तरह का लेख एक शैक्षिक अर्थ में उपयोगी है और इसमें कुछ सौंदर्य पूर्णता है।