उदाहरण 1:
'आईओस्ट्रीम' वह हेडर फ़ाइल है जिसे हम यहां शामिल करते हैं क्योंकि हमें इस हेडर फ़ाइल में घोषित फ़ंक्शंस का उपयोग करना है। 'iostream' हेडर फ़ाइल में एक फ़ंक्शन घोषणा शामिल है। यहाँ 'std' नामस्थान भी जोड़ा गया है। फिर, हम 'फ़ंक्टरक्लास' नामक एक क्लास बनाते हैं। इसके नीचे, हम 'पब्लिक' टाइप करते हैं जो यहां पब्लिक कंस्ट्रक्टर है और 'ऑपरेटर ()' फ़ंक्शन डालते हैं। फिर, हम एक वाक्य डालते हैं जिसे हम स्क्रीन पर 'काउट' स्टेटमेंट में प्रस्तुत करना चाहते हैं।
इसके बाद, हम 'मेन()' फ़ंक्शन को कॉल करते हैं और फिर 'फंक्टरक्लास' का ऑब्जेक्ट 'my_functor' नाम से बनाते हैं। यहां, हम 'my_functor()' फ़ंक्शन को कॉल करते हैं, इसलिए यह वह कथन प्रदर्शित करता है जिसे हमने 'ऑपरेटर()' फ़ंक्शन के नीचे जोड़ा है।
कोड 1:
#शामिल करें
का उपयोग करते हुए नाम स्थान कक्षा ;
कक्षा फ़ंक्टरक्लास {
जनता :
खालीपन ऑपरेटर ( ) ( ) {
अदालत << 'ऑपरेशन यहाँ कहा जाता है' ;
}
} ;
int यहाँ मुख्य ( ) {
फ़नक्टरक्लास my_functor ;
my_functor ( ) ;
वापस करना 0 ;
}
आउटपुट:
'फ़ंक्टरक्लास' के 'ऑपरेटर ()' फ़ंक्शन में हमने जो लाइन जोड़ी है, वह 'my_functor' फ़ंक्टर ऑब्जेक्ट का उपयोग करके यहां प्रदर्शित की गई है।
उदाहरण 2:
हम यहां 'iostream' हेडर फ़ाइल को शामिल करते हैं क्योंकि कुछ फ़ंक्शन घोषणा 'iostream' हेडर फ़ाइल में समाहित है। 'एसटीडी' नेमस्पेस भी डाला गया है। इसके बाद, हम 'स्क्वायरक्लास' नामक एक क्लास बनाते हैं।
उसके नीचे, हम 'सार्वजनिक' टाइप करते हैं जो कि सार्वजनिक कंस्ट्रक्टर है और उसके नीचे 'int' डेटा प्रकार के 'ऑपरेटर ()' फ़ंक्शन को रखते हैं। हम 'int' डेटा प्रकार के 'वैल' वेरिएबल को इस 'ऑपरेटर ()' फ़ंक्शन में पास करते हैं। यह फ़ंक्शन गुणन परिणाम लौटाता है क्योंकि हमने 'ऑपरेटर ()' फ़ंक्शन के नीचे 'रिटर्न ()' फ़ंक्शन में 'वैल * वैल' डाला था।
अब, 'मुख्य()' फ़ंक्शन को यहां कहा जाता है। फिर, यहां ऑब्जेक्ट को 'स्क्वायरफ़ंक्टर' वर्ग के 's_functor' नाम से बनाया गया है। फिर, हम 'काउट' का उपयोग करते हैं जो जानकारी प्रदान करने में सहायता करता है। इसके बाद, हम यहां 'my_functor()' ऑब्जेक्ट को एक फ़ंक्शन की तरह कॉल करते हैं और यह '5 * 5' का गुणन परिणाम देता है क्योंकि हमने इसे कॉल करते समय पैरामीटर के रूप में '5' जोड़ा था।
कोड 2:
#शामिल करेंका उपयोग करते हुए नाम स्थान कक्षा ;
कक्षा स्क्वायरक्लास {
जनता :
int यहाँ ऑपरेटर ( ) ( int यहाँ वैल ) {
वापस करना ( वैल * वैल ) ;
}
} ;
int यहाँ मुख्य ( ) {
स्क्वायरक्लास s_functor ;
अदालत << 'दिए गए मान का वर्ग है' << अंतः ;
अदालत << s_function ( 5 ) ;
वापस करना 0 ;
}
आउटपुट:
हमें 'SqaureClass' क्लास के 'my_functor' ऑब्जेक्ट को 'my_functor()' फ़ंक्शन की तरह कॉल करने और फिर '5' पास करने के बाद आउटपुट मिलता है। हमें संख्या '5' के वर्ग के रूप में '25' प्राप्त होता है।
उदाहरण 3:
'iostream' हेडर फ़ाइल यहां शामिल है क्योंकि इसमें एक फ़ंक्शन घोषणा शामिल है, और 'std' नेमस्पेस बाद में पेश किया गया है। फिर “ProductFunctor” वर्ग बनाया जाता है। सार्वजनिक कंस्ट्रक्टर, 'सार्वजनिक', इसके नीचे टाइप किया गया है और 'int' डेटा प्रकार का 'ऑपरेटर ()' फ़ंक्शन इसके नीचे स्थित है। हम यहां इस फ़ंक्शन को ओवरराइड करते हैं और इसमें दो पैरामीटर पास करते हैं: 'int var1' और 'int var2'।
फिर, हम इसके नीचे 'रिटर्न' का उपयोग करते हैं और दोनों वेरिएबल्स को गुणा करते हैं जो दोनों संख्याओं 'var1 * var2' का गुणन परिणाम लौटाते हैं। फिर 'मेन()' फ़ंक्शन को यहां कॉल किया जाता है और हम 'प्रोडक्टफ़ंक्टर' क्लास के 'P_functor' नाम के साथ क्लास ऑब्जेक्ट उत्पन्न करते हैं। फिर, हम 'pro_result' नाम से एक नया वेरिएबल प्रारंभ करते हैं और कॉल करने के बाद 'P_functor' ऑब्जेक्ट को 'P_functor()' फ़ंक्शन के रूप में असाइन करते हैं।
हम पैरामीटर के रूप में '28' और '63' पास करते हैं। यह दोनों मानों को गुणा करेगा और परिणाम को 'pro_result' वेरिएबल में सहेजेगा जिसे हम 'cout' का उपयोग करके और इसमें 'pro_result' पास करके इसके नीचे प्रिंट करते हैं।
कोड 3:
#शामिल करेंका उपयोग करते हुए नाम स्थान कक्षा ;
कक्षा उत्पादफ़ंक्टर {
जनता :
int यहाँ ऑपरेटर ( ) ( int यहाँ var1, int यहाँ var2 ) {
वापस करना var1 * var2 ;
}
} ;
int यहाँ मुख्य ( ) {
प्रोडक्टफ़ंक्टर P_फ़ंक्टर ;
int यहाँ उत्पाद_परिणाम = पी_फंक्शन ( 28 , 63 ) ;
अदालत << 'उत्पाद है:' << उत्पाद_परिणाम << अंतः ;
वापस करना 0 ;
}
आउटपुट:
हमें 'P_functor' ऑब्जेक्ट को 'P_functor()' फ़ंक्शन के रूप में कॉल करने और उसमें मान भेजने के बाद उत्पाद मिलता है। उन मानों का गुणनफल '1764' है।
उदाहरण 4:
इस उदाहरण में 'ग्रीटिंगफ़ंक्टरक्लास' उत्पन्न होता है। फिर, हम 'पब्लिक' कंस्ट्रक्टर डालते हैं और इस 'पब्लिक' कंस्ट्रक्टर में 'ऑपरेटर ()' फ़ंक्शन को ओवरराइड करते हैं। हम टाइप करते हैं “हैलो! 'ऑपरेटर()' फ़ंक्शन के नीचे 'काउट' रखने के बाद मैं यहां एक सी++ प्रोग्रामर हूं।
अब आगे, हम 'मुख्य()' कहते हैं। हम यहां 'G_functor' को 'GreetingFunctorClass' के ऑब्जेक्ट के रूप में बनाते हैं और फिर इस 'g_functor' ऑब्जेक्ट को 'g_functor()' फ़ंक्शन के रूप में कॉल करते हैं। यह वह परिणाम देता है जो हमने 'ऑपरेटर ()' फ़ंक्शन को ओवरराइड करते समय जोड़ा था।
कोड 4:
#शामिल करेंका उपयोग करते हुए नाम स्थान कक्षा ;
का उपयोग करते हुए नाम स्थान कक्षा ;
कक्षा ग्रीटिंगफ़ंक्टरक्लास {
जनता :
खालीपन ऑपरेटर ( ) ( ) {
अदालत << 'नमस्कार! मैं यहाँ एक C++ प्रोग्रामर हूँ' ;
}
} ;
int यहाँ मुख्य ( ) {
ग्रीटिंगफ़ंक्टरक्लास g_functor ;
g_function ( ) ;
वापस करना 0 ;
}
आउटपुट:
यहां, हम देख सकते हैं कि जब हम अपने कोड में 'ऑपरेटर ()' फ़ंक्शन को ओवरराइड करते हैं तो हमने जो स्टेटमेंट जोड़ा है वह यहां प्रदर्शित होता है क्योंकि हम क्लास ऑब्जेक्ट को फ़ंक्शन की तरह कहते हैं।
उदाहरण 5:
इस बार 'बिट्स/stdc++.h' को शामिल किया गया है क्योंकि इसमें सभी आवश्यक फ़ंक्शन घोषणाएँ शामिल हैं। फिर, 'std' नेमस्पेस यहां रखा गया है। जो क्लास हम यहां बनाते हैं वह 'incrementFunctor' क्लास है। फिर, हम एक 'निजी' कंस्ट्रक्टर बनाते हैं और 'int_num' वेरिएबल को 'int' डेटा प्रकार के साथ प्रारंभ करते हैं।
इसके नीचे, 'सार्वजनिक' कंस्ट्रक्टर, हम 'इंक्रीमेंटफ़ंक्टर' रखते हैं और इसके अंदर 'int n1' पास करते हैं। फिर, हम ':' रखने के बाद 'int_num(n1)' टाइप करते हैं। फिर, हम उस फ़ंक्शन को ओवरराइड करते हैं जो 'int' डेटा प्रकार का 'ऑपरेटर ()' फ़ंक्शन है और यहां 'int arrOfNum' घोषित करते हैं। फिर हम 'रिटर्न' का उपयोग करते हैं और 'int_num + arrOfNum' डालते हैं। अब, यह 'arrOfNum' के मान को बढ़ाता है, उनमें 'int_num' मान जोड़ता है, और उन्हें यहां लौटाता है।
'मुख्य()' को लागू करने के बाद, हम 'arrOfNum' को आरंभ करते हैं और यहां अलग-अलग पूर्णांक मान निर्दिष्ट करते हैं। फिर, 'n1' वेरिएबल को आरंभ किया जाता है जहां हम 'sizeof(arrOfNum)/sizeof(arrOfNum[0])' जैसे 'sizeof' फ़ंक्शन जोड़ते हैं। इसके बाद, 'अतिरिक्त संख्या' को '3' से प्रारंभ किया जाता है। अब, हम 'ट्रांसफ़ॉर्म()' फ़ंक्शन का उपयोग करते हैं। यह 'ट्रांसफॉर्म ()' 'इंक्रीमेंटफ़ंक्टर' क्लास का ऑब्जेक्ट बनाने और फिर उसके ऑब्जेक्ट को कॉल करने के समान है। इसके बाद, हम 'for' लूप का उपयोग करते हैं और फिर 'arrOfNum[i]' को 'काउट' करते हैं।
कोड 5:
#शामिल हैका उपयोग करते हुए नाम स्थान कक्षा ;
कक्षा वेतन वृद्धिफ़ंक्टर
{
निजी :
int यहाँ int_num ;
जनता :
वेतन वृद्धिफ़ंक्टर ( int यहाँ एन 1 ) : int_num ( एन 1 ) { }
int यहाँ ऑपरेटर ( ) ( int यहाँ arrOfNum ) कॉन्स्ट {
वापस करना int_num + arrOfNum ;
}
} ;
int यहाँ मुख्य ( )
{
int यहाँ arrOfNum [ ] = { 6 , 3 , 2 , 1 , 9 , 0 , 8 } ;
int यहाँ एन 1 = का आकार ( arrOfNum ) / का आकार ( arrOfNum [ 0 ] ) ;
int यहाँ अतिरिक्त संख्या = 3 ;
परिवर्तन ( arrOfNum, arrOfNum + n1, arrOfNum, इन्क्रीमेंटफ़ंक्टर ( अतिरिक्त संख्या ) ) ;
के लिए ( int यहाँ मैं = 0 ; मैं < एन 1 ; मैं ++ )
अदालत << arrOfNum [ मैं ] << ' ' ;
}
आउटपुट:
कोड का परिणाम यहां दिखाया गया है जिसमें 'incrementFunctor' 'Functor' है जिसका उपयोग फ़ंक्शन के रूप में किया जाता है।
उदाहरण 6:
इस कोड में, हम पूर्वनिर्धारित 'बड़े' फ़ैक्टर का उपयोग करते हैं। यहां, हम चार अलग-अलग हेडर फ़ाइलों को शामिल करते हैं क्योंकि हमें अपने कोड में उनकी आवश्यकता होती है क्योंकि हमारे कोड में जिन फ़ंक्शन या विधियों की हमें आवश्यकता होती है वे उनमें घोषित होते हैं। फिर, 'std' जोड़ने और फिर 'main()' को कॉल करने के बाद, हम 'myIntegerVector' वेक्टर को इनिशियलाइज़ करते हैं। हम इस वेक्टर में कुछ अवर्गीकृत मान सम्मिलित करते हैं। इसके नीचे, हम इन वेक्टर मानों को क्रमबद्ध करने के लिए 'सॉर्ट' फ़ंक्शन लागू करते हैं।
जब हम इस फ़ंक्शन का उपयोग करते हैं, तो यह मानों को आरोही क्रम में क्रमबद्ध करता है। लेकिन हम यहां 'ग्रेटर' का उपयोग करते हैं जो C++ में पूर्वनिर्धारित फ़ंक्शन है जो अवरोही तरीके से सॉर्टिंग का परिणाम देता है। इसके बाद, हम 'फॉर' लूप और फिर 'काउट' की सहायता से क्रमबद्ध मान प्रदर्शित करते हैं।
कोड 6:
#शामिल करें#<एल्गोरिदम>शामिल करें
#शामिल <वेक्टर>
#शामिल <कार्यात्मक>
का उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
वेक्टर < int यहाँ > myIntegerVector = { 13 , इक्कीस , 19 , 44 , 32 , 42 , 9 , 6 } ;
क्रम से लगाना ( myIntegerVector. शुरू ( ) , myIntegerVector. अंत ( ) , अधिक से अधिक < int यहाँ > ( ) ) ;
के लिए ( int यहाँ vec_num : myIntegerVector ) {
अदालत << vec_num << '' ;
}
वापस करना 0 ;
}
आउटपुट:
वेक्टर के सभी मानों को C++ में पूर्वनिर्धारित फ़ैक्टर की सहायता से अवरोही तरीके से क्रमबद्ध किया जाता है जो कि 'बड़ा' फ़ैक्टर है, और इसकी परिभाषा 'फ़ंक्शनल' हेडर फ़ाइल में उपलब्ध है।
निष्कर्ष
इस लेख में 'फ़ंक्टर C++' की अवधारणा का गहराई से पता लगाया गया है। हमने अध्ययन किया कि किसी ऑब्जेक्ट को 'ऑपरेटर()' नामक फ़ंक्शन को ओवरलोड करने के लिए एक फ़ंक्शन के रूप में लागू किया जा सकता है। इसे फ़नकार के रूप में जाना जाता है। 'ऑपरेटर ()' के ओवरलोडिंग को उद्देश्य के अनुसार उपयोग करने के लिए सार्वजनिक पहुंच प्रदान की जानी चाहिए। हमने विभिन्न उदाहरणों का वर्णन किया है जिसमें हमने अपने कोड में 'फ़ंक्टर' और पूर्वनिर्धारित 'फ़ंक्टर' का उपयोग किया है।