उदाहरण 1:
परिभाषित कार्यों का उपयोग करना आसान बनाने के लिए हम 'iostream' हेडर फ़ाइल शामिल करते हैं। फिर, हमारे पास 'नेमस्पेस एसटीडी' है। इसके नीचे, हम 'MyNewClass' नामक क्लास बनाते हैं और 'पब्लिक' कंस्ट्रक्टर का उपयोग करते हैं।
'पब्लिक' में, हम 'myFunc' नामक सदस्य फ़ंक्शन बनाते हैं और 'int num' को 'myFunc()' के पैरामीटर के रूप में घोषित करते हैं। इसके नीचे, हम 'काउट' का उपयोग करते हैं और इसके नीचे मुख्य() विधि को लागू करते हैं जिसमें हम सदस्य फ़ंक्शन पॉइंटर बनाते हैं। हम 'MyNewClass' वर्ग और पैरामीटर प्रकार (int) को निर्दिष्ट करते हुए, सदस्य फ़ंक्शन प्रकार के लिए 'MyFuncPtr' पॉइंटर घोषित करते हैं।
इसके बाद, हम 'Class_obj' नामक क्लास ऑब्जेक्ट बनाते हैं और फिर क्लास ऑब्जेक्ट को इसके साथ रखकर '*MyFuncPtr' पॉइंटर की सहायता से सदस्य फ़ंक्शन को कॉल करते हैं। जब हम सदस्य फ़ंक्शन पॉइंटर को कॉल करते हैं तो हम इसे प्रस्तुत करने के लिए पैरामीटर के रूप में '10' निर्दिष्ट करते हैं।
कोड 1:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना ;
कक्षा MyNewClass {
जनता :
खालीपन myFunc ( int यहाँ एक पर ) {
अदालत << 'मूल्य है' << एक पर << अंतः ;
}
} ;
int यहाँ मुख्य ( ) {
खालीपन ( मेरी नई कक्षा ::* MyFuncPtr ) ( int यहाँ ) = & मेरी नई कक्षा :: myFunc ;
MyNewClass Class_obj ;
( क्लास_ओबीजे. * MyFuncPtr ) ( 10 ) ;
वापस करना 0 ;
}
आउटपुट:
यह सदस्य फ़ंक्शन पॉइंटर्स की कार्यप्रणाली को दर्शाता है। सदस्य फ़ंक्शन पॉइंटर का उपयोग वर्तमान परिस्थितियों के अनुसार सदस्य कार्यों को गतिशील रूप से लॉन्च करने के लिए किया जा सकता है।
उदाहरण 2:
'iostream' हेडर फ़ाइल में परिभाषित फ़ंक्शंस का सरल उपयोग करने के लिए, हम यहां 'iostream' शामिल करते हैं। 'नेमस्पेस एसटीडी' को आगे रखा गया है। इसके नीचे, हम 'टेस्ट' क्लास बनाते हैं और फिर 'पब्लिक' कंस्ट्रक्टर का उपयोग करते हैं। हम 'myTestingFunc' सदस्य फ़ंक्शन को 'सार्वजनिक' में परिभाषित करते हैं और इस उदाहरण में 'myTestingFunc()' के पैरामीटर के रूप में 'int t_value' सेट करते हैं। नीचे 'काउट' फ़ंक्शन का उपयोग किया गया है और मुख्य() विधि को कॉल किया गया है। फिर, हम सदस्य फ़ंक्शन पॉइंटर बनाते हैं।
हम यहां 'टेस्ट' क्लास और '*MyTestFuncPtr' सदस्य फ़ंक्शन पॉइंटर निर्दिष्ट करते हैं। हम सदस्य फ़ंक्शन पॉइंटर को '&Test::myTestingFunc' असाइन करते हैं जिसे 'void (Test::*MyTestFuncPtr)(int)' के रूप में घोषित किया जाता है।
इसके बाद, हम 't_obj' क्लास ऑब्जेक्ट जेनरेट करते हैं और इसका उपयोग क्लास ऑब्जेक्ट डालकर और '*MyTestFuncPtr' पॉइंटर का उपयोग करके सदस्य फ़ंक्शन को कॉल करने के लिए करते हैं। इसे प्रस्तुत करने के लिए जब हम सदस्य फ़ंक्शन पॉइंटर को कॉल करते हैं, तो हम पैरामीटर के रूप में '932' निर्दिष्ट करते हैं।
कोड 2:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना ;
क्लास टेस्ट {
जनता :
खालीपन myTestingFunc ( int यहाँ t_मान ) {
अदालत << 'परीक्षण मूल्य है' << t_मान << अंतः ;
}
} ;
int यहाँ मुख्य ( ) {
खालीपन ( परीक्षा ::* MyTestFuncPtr ) ( int यहाँ ) = & परीक्षा :: myTestingFunc ;
परीक्षण t_obj ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
वापस करना 0 ;
}
आउटपुट:
दिए गए कोड का परिणाम प्रस्तुत किया गया है। हम देख सकते हैं कि हमने क्लास ऑब्जेक्ट के साथ 'सदस्य फ़ंक्शन पॉइंटर' कहा है जैसा कि यहां दिखाया गया है।
उदाहरण 3:
इस कोड में हम जो वर्ग उत्पन्न करते हैं वह 'MyNewCar' है जहां हम 'सार्वजनिक' कंस्ट्रक्टर का उपयोग करते हैं और इसमें सदस्य फ़ंक्शन बनाते हैं जो 'startCarEngine()' है। इस फ़ंक्शन में, हम 'काउट' जोड़ते हैं जो हमारे कोड में इस फ़ंक्शन को कॉल करने पर प्रस्तुत होता है। फिर, हम एक और सदस्य फ़ंक्शन बनाते हैं जो 'stopCarEngine()' है और इस सदस्य फ़ंक्शन में फिर से 'cout' का उपयोग करते हैं।
इसके बाद, हम मुख्य() फ़ंक्शन को लागू करते हैं और फिर सदस्य फ़ंक्शन पॉइंटर घोषित करते हैं जो 'MyNewCar::*carEngineFunc()' है। इसके नीचे, हम 'myNewCar' क्लास ऑब्जेक्ट को 'myCar_obj' नाम से बनाते हैं। फिर, हम 'startCarEngine' फ़ंक्शन को 'carEngineFunc' पॉइंटर पर असाइन करते हैं। इसके नीचे, हम ऑब्जेक्ट नाम को इसके साथ रखकर 'carEngineFunc' पॉइंटर की सहायता से इस फ़ंक्शन को कॉल करते हैं।
इसके बाद, हम 'stopCarEngine' फ़ंक्शन को 'carEngineFunc' पॉइंटर पर पुनः असाइन करते हैं। उसके नीचे, हम 'carEngineFunc' संदर्भ के साथ ऑब्जेक्ट नाम पास करके इस फ़ंक्शन को कॉल करते हैं।
कोड 3:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना ;
कक्षा MyNewCar {
जनता :
खालीपन स्टार्टकारइंजन ( ) {
अदालत << 'कार का इंजन चालू हो गया' << अंतः ;
}
खालीपन स्टॉपकारइंजन ( ) {
अदालत << 'कार का इंजन बंद हो जाता है' << अंतः ;
}
} ;
int यहाँ मुख्य ( ) {
खालीपन ( मेरी नयी कार ::* कारइंजनफनक ) ( ) ;
MyNewCar myCar_obj ;
कारइंजनफनक = & मेरी नयी कार :: स्टार्टकारइंजन ;
( myCar_obj. * कारइंजनफनक ) ( ) ;
कारइंजनफनक = & मेरी नयी कार :: स्टॉपकारइंजन ;
( myCar_obj. * कारइंजनफनक ) ( ) ;
वापस करना 0 ;
}
आउटपुट:
यहां, 'सदस्य फ़ंक्शन पॉइंटर' की कार्यप्रणाली प्रदर्शित होती है। हम देख सकते हैं कि हमने सदस्य फ़ंक्शन पॉइंटर बनाया और परिणाम यहां प्रदर्शित किया।
उदाहरण 4:
हेडर फ़ाइल और 'std नेमस्पेस' को शामिल करने के बाद, हम यहां 'MyNewStudent' क्लास घोषित करते हैं। 'स्टूडेंटपास()' सदस्य फ़ंक्शन उन सदस्य फ़ंक्शंस में से एक है जिसे हम 'माईस्टूडेंटक्लास' क्लास के लिए बनाते हैं जिसे हम यहां उत्पन्न करते हैं। हम इस फ़ंक्शन में 'काउट' भी जोड़ते हैं जो हमारे कोड में कॉल करने पर रेंडर हो जाएगा।
इसके बाद, हम 'स्टूडेंटफेल()' सदस्य फ़ंक्शन लिखते हैं जहां हम एक बार फिर 'काउट' का उपयोग करते हैं। फिर मुख्य() फ़ंक्शन को कॉल किया जाता है और '(MyNewStudent::*studentResultFunc)()' सदस्य फ़ंक्शन पॉइंटर घोषित किया जाता है। उसके नीचे, हम 'myStd_obj' ऑब्जेक्ट उत्पन्न करते हैं जो 'MyNewStudent' वर्ग से संबंधित है।
इसके बाद, हम 'studentPass' फ़ंक्शन को 'studentResultFunc' पॉइंटर पर असाइन करते हैं। उसके नीचे, हम ऑब्जेक्ट नाम को 'studentResultFunc' संदर्भ के साथ पास करके इस फ़ंक्शन को कॉल करते हैं। 'स्टूडेंटफ़ेल' फ़ंक्शन को 'studentResultFunc' पॉइंटर पर पुनः असाइन किया गया है। उसके नीचे, हम 'carEngineFunc' संदर्भ और ऑब्जेक्ट नाम देकर इस विधि को लागू करते हैं।
अब, दोनों फ़ंक्शंस को यहां बुलाया जाता है और जो कथन हमने इन फ़ंक्शंस में शामिल किए हैं, उन्हें प्रस्तुत किया गया है।
कोड 4:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना ;
कक्षा MyNewStudent {
जनता :
खालीपन छात्रपास ( ) {
अदालत << 'छात्र उत्तीर्ण' << अंतः ;
}
खालीपन छात्रअसफल ( ) {
अदालत << 'छात्र फेल' << अंतः ;
}
} ;
int यहाँ मुख्य ( ) {
खालीपन ( मेरा नया छात्र ::* studentResultFunc ) ( ) ;
MyNewStudent myStd_obj ;
studentResultFunc = & मेरा नया छात्र :: छात्रपास ;
( myStd_obj. * studentResultFunc ) ( ) ;
studentResultFunc = & मेरा नया छात्र :: छात्रअसफल ;
( myStd_obj. * studentResultFunc ) ( ) ;
वापस करना 0 ;
}
आउटपुट:
हमने अपने कोड में सदस्य फ़ंक्शन और फिर सदस्य फ़ंक्शन पॉइंटर बनाया। इसके बाद, हमने सदस्य फ़ंक्शन को कॉल किया और परिणाम यहां प्रदर्शित किया।
उदाहरण 5:
इस उदाहरण में 'सैंपलक्लास' बनाया गया है। फिर, सदस्य फ़ंक्शन पॉइंटर को यहां रखा गया है जो '(SampleClass::*MyFunc)()' है। इसके नीचे, हम फ़ंक्शन पॉइंटर बनाते हैं जो '(*MyFuncPtr)()' है। इसके नीचे, हम 'स्ट्रिंग' वेरिएबल के 'नाम' के साथ-साथ 'MyFunc f' सदस्य फ़ंक्शन पॉइंटर की घोषणा करते हैं।
इसके बाद, हमारे पास 'पब्लिक' कंस्ट्रक्टर है जहां हम इस सदस्य फ़ंक्शन वेरिएबल को परिभाषित करते हैं। इसके नीचे, हम 'myFunc_1()' और 'myFunc_1()' नामक सदस्य फ़ंक्शन बनाते हैं और प्रत्येक सदस्य फ़ंक्शन में 'cout' भी जोड़ते हैं जो इस सदस्य फ़ंक्शन को कॉल करने पर प्रदर्शित होगा।
फिर, हम इस सदस्य फ़ंक्शन पॉइंटर को '(this->*f)()' की सहायता से कॉल करते हैं। फिर, हम फ़ंक्शंस को फिर से रखते हैं। यहां, हम उन 'काउट' कथनों को बदलते हैं जिन्हें हमने पहले जोड़ा था। फिर, 'मुख्य()' अब लागू किया गया है और सदस्य फ़ंक्शन पॉइंटर को 'MyFunc f = &SampleClass::myFunc_2' के रूप में परिभाषित किया गया है।
फिर, फ़ंक्शन पॉइंटर को 'MyFuncPtr fp = myFunc_1' के रूप में भी परिभाषित किया गया है। इसके बाद, हम सदस्य फ़ंक्शन पॉइंटर का उपयोग करने के लिए '(a.*f)()' टाइप करते हैं। सदस्य फ़ंक्शन का उपयोग करने के लिए 'b.func' रखा गया है। फिर, हम फ़ंक्शन पॉइंटर को कॉल करने के लिए 'fp()' डालते हैं।
कोड 5:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना ;
क्लास सैंपलक्लास ;
टाइपडेफ़ खालीपन ( नमूनावर्ग ::* माईफनक ) ( ) ;
टाइपडेफ़ खालीपन ( * MyFuncPtr ) ( ) ;
क्लास सैंपलक्लास {
स्ट्रिंग नाम ;
माईफंक एफ ;
जनता :
नमूनावर्ग ( कॉन्स्ट चार * नाम )
: नाम ( नाम ) ,
एफ ( & नमूनावर्ग :: myFunc_1 )
{ }
खालीपन myFunc_1 ( ) { अदालत << नाम << 'हमने यहां फक्शन 1 को बुलाया है' << अंतः ; }
खालीपन myFunc_2 ( ) { अदालत << नाम << 'हमने यहां फ़ंक्शन 2 को कॉल किया है' << अंतः ; }
खालीपन समारोह ( ) {
( यह ->* एफ ) ( ) ;
}
} ;
खालीपन myFunc_1 ( ) { अदालत << 'पहला समारोह' << अंतः ; }
खालीपन myFunc_2 ( ) { अदालत << 'दूसरा कार्य' << अंतः ; }
int यहाँ मुख्य ( )
{
माईफंक एफ = & नमूनावर्ग :: myFunc_2 ;
MyFuncPtr एफपी = myFunc_1 ;
नमूनावर्ग ए ( 'पहला - ' ) , बी ( 'दूसरा - ' ) ;
( एक। * एफ ) ( ) ;
बी। समारोह ( ) ;
एफपी ( ) ;
}
आउटपुट:
कोड का परिणाम अब यहां प्रस्तुत किया गया है जो परिणाम को उसी के अनुसार प्रस्तुत करता है जैसा कि हम अपने कोड में फ़ंक्शन कहते हैं।
निष्कर्ष
हमने पता लगाया कि C++ में 'सदस्य फ़ंक्शन पॉइंटर्स' OOP के संदर्भ में गतिशील बाइंडिंग, व्यवहार के इनकैप्सुलेशन और फ़ंक्शन इनवोकेशन के लचीले संचालन को आसान बनाते हैं। हमने सीखा कि 'सदस्य फ़ंक्शन पॉइंटर्स' का उपयोग सी ++ कोडबेस की मॉड्यूलरिटी और लचीलेपन में काफी सुधार कर सकता है, जो कई डिज़ाइन और रनटाइम चुनौतियों को संबोधित करने के लिए एक शक्तिशाली उपकरण प्रदान करता है।