C++ में फंक्टर: वे क्या हैं और कोड को कैसे सरल बनाते हैं? पूर्ण गाइड

C++ में फंक्टर क्या हैं और इनकी आवश्यकता क्यों है?

कल्पना करें कि आप C++ में कोड लिख रहे हैं और आपको किसी दूसरे फंक्शन में व्यवहार (फंक्शन) पास करना है, उदाहरण के लिए, डेटा को सॉर्ट या फ़िल्टर करने के लिए। क्लासिक समाधान फंक्शन पॉइंटर्स है। लेकिन उनमें कमियां हैं: वे स्थिति (state) संग्रहीत नहीं कर सकते, उन्हें इनलाइन करना मुश्किल है, और वे थोड़े पुरातन दिखते हैं। यहाँ पर C++ में फंक्टर (जिन्हें ऑब्जेक्ट-फंक्शन या C++ फंक्शनल ऑब्जेक्ट भी कहा जाता है) दृश्य पर आते हैं।

फंक्टर एक सामान्य क्लास या स्ट्रक्चर है, जिसमें फंक्शन कॉल ऑपरेटर operator() को पुनर्परिभाषित किया गया है। इसके कारण, ऐसी क्लास के इंस्टेंस को सामान्य फंक्शन की तरह इस्तेमाल किया जा सकता है। यह जटिल लगता है? वास्तव में यह C++ के सबसे सुंदर टूल्स में से एक है। Stack Overflow पर प्रश्न "What are C++ functors and their uses?" ने हजारों बार देखा गया है — डेवलपर्स इस विषय को समझना चाहते हैं ताकि वे अधिक लचीला और कुशल कोड लिख सकें। इस गाइड में हम सब कुछ चरणबद्ध तरीके से समझाएंगे: बुनियादी सिंटैक्स से लेकर STL के साथ वास्तविक उपयोग के उदाहरणों तक।

बुनियादी सिंटैक्स: अपना पहला फंक्टर कैसे बनाएं

फंक्टर बनाना तीन चरणों में होता है:

\n
• एक क्लास या स्ट्रक्चर घोषित करें।
\n
• अंदर आवश्यक सिग्नेचर (पैरामीटर और रिटर्न टाइप) के साथ operator() को लागू करें।
\n
• इस क्लास का एक ऑब्जेक्ट बनाएं और इसे फंक्शन की तरह कॉल करें।
\n

यहाँ एक सबसे सरल C++ फंक्टर उदाहरण है, जो किसी संख्या को दो से गुणा करता है:

#include <iostream>\n\nclass Multiplier {\npublic:\n    // ऑपरेटर () को पुनर्परिभाषित करें\n    int operator()(int x) const {\n        return x * 2;\n    }\n};\n\nint main() {\n    Multiplier mult;  // ऑब्जेक्ट-फंक्शन बनाएं\n    std::cout << mult(5) << std::endl; // आउटपुट: 10\n    std::cout << mult(10) << std::endl; // आउटपुट: 20\n    return 0;\n}

ध्यान दें: mult(5) सामान्य फंक्शन कॉल जैसा दिखता है, लेकिन वास्तव में यह mult.operator()(5) का कॉल है। कंपाइलर सिंटैक्टिक शुगर प्रदान करता है, और कोड साफ और सहज बनता है।

मुख्य लाभ: फंक्टर स्थिति (state) संग्रहीत कर सकते हैं

सामान्य फंक्शन या लैम्ब्डा एक्सप्रेशन (C++11 से पहले) के विपरीत, C++ फंक्शन ऑब्जेक्ट के अपने स्वयं के मेंबर फील्ड हो सकते हैं। यह बहुत बड़ी संभावनाएं खोलता है। उदाहरण के लिए, आप एक ऐसा फंक्टर बना सकते हैं जो न केवल कार्य करता है, बल्कि यह भी याद रखता है कि इसे कितनी बार कॉल किया गया:

#include <iostream>\n\nclass Counter {\nprivate:\n    int count = 0;\npublic:\n    int operator()() {\n        return ++count;\n    }\n    int getCount() const { return count; }\n};\n\nint main() {\n    Counter counter;\n    std::cout << counter() << std::endl; // 1\n    std::cout << counter() << std::endl; // 2\n    std::cout << counter() << std::endl; // 3\n    // स्थिति कॉल के बीच संरक्षित रहती है!\n    return 0;\n}

यह स्थिति वाला C++ फंक्टर उदाहरण ग्लोबल वेरिएबल्स (जो खराब है) के उपयोग के बिना एक साधारण फंक्शन के साथ लागू नहीं किया जा सकता। फंक्टर इस समस्या को सुंदर और सुरक्षित रूप से हल करते हैं।

फंक्टर और STL एल्गोरिदम: एक आदर्श संयोजन

फंक्टर का सबसे शक्तिशाली उपयोग Standard Template Library (STL) के एल्गोरिदम के साथ काम करना है। std::sort, std::find_if, std::for_each जैसे एल्गोरिदम इनपुट के रूप में एक कॉल करने योग्य ऑब्जेक्ट (callable) की अपेक्षा करते हैं। आप उन्हें एक फंक्टर पास कर सकते हैं, और वह आवश्यक लॉजिक निष्पादित करेगा।

उदाहरण: फंक्टर के साथ सॉर्टिंग

मान लीजिए, आपके पास संख्याओं का एक वेक्टर है, और आप उन्हें अवरोही क्रम में सॉर्ट करना चाहते हैं। आप अपना स्वयं का तुलना फंक्टर लिख सकते हैं:

#include <iostream>\n#include <vector>\n#include <algorithm>\n\nclass Descending {\npublic:\n    bool operator()(int a, int b) const {\n        return a > b; // रिटर्न