C++ उदाहरण के साथ बहुरूपता

बहुरूपता क्या है? C++?

In C++पॉलीमॉर्फिज्म के कारण, एक सदस्य फ़ंक्शन उस ऑब्जेक्ट के आधार पर अलग-अलग व्यवहार करता है जो उसे कॉल/इनवोक करता है। पॉलीमॉर्फिज्म एक ग्रीक शब्द है जिसका अर्थ है अनेक रूप होना। यह तब होता है जब आपके पास एक पदानुक्रम होता है। कक्षाएं वंशानुक्रम के माध्यम से संबंधित।

उदाहरण के लिए, मान लीजिए हमारे पास makeSound() फ़ंक्शन है। जब बिल्ली इस फ़ंक्शन को कॉल करती है, तो यह म्याऊँ की आवाज़ पैदा करेगी। जब गाय इसी फ़ंक्शन को कॉल करती है, तो यह म्याऊँ की आवाज़ पैदा करेगी।

हालाँकि हमारे पास एक फ़ंक्शन है, लेकिन यह अलग-अलग परिस्थितियों में अलग-अलग तरीके से व्यवहार करता है। फ़ंक्शन के कई रूप हैं; इसलिए, हमने बहुरूपता हासिल कर ली है।

मूल विचार स्पष्ट हो जाने के बाद, C++ यह व्यवहार दो अलग-अलग श्रेणियों में व्यवस्थित किया गया है।

बहुरूपता के प्रकार

C++ दो प्रकार के बहुरूपता का समर्थन करता है:

• संकलन-समय बहुरूपता, और
• रनटाइम बहुरूपता.

पहली श्रेणी प्रोग्राम के चलने से पहले ही प्रत्येक फ़ंक्शन कॉल को हल कर देती है।

संकलन समय बहुरूपता

आप तर्कों की संख्या और प्रकार का मिलान करके ओवरलोडेड फ़ंक्शन को आमंत्रित करते हैं। जानकारी संकलन-समय के दौरान मौजूद रहती है। इसका मतलब है कि C++ कम्पाइलर संकलन समय पर सही फ़ंक्शन का चयन करेगा।

संकलन-समय बहुरूपता फ़ंक्शन ओवरलोडिंग और ऑपरेटर ओवरलोडिंग के माध्यम से प्राप्त की जाती है।

फंक्शन ओवरलोडिंग

फ़ंक्शन ओवरलोडिंग तब होती है जब हमारे पास समान नाम वाले कई फ़ंक्शन होते हैं लेकिन अलग-अलग तर्क होते हैं। तर्क संख्या या प्रकार के संदर्भ में भिन्न हो सकते हैं।

उदाहरण 1

#include <iostream> 
using namespace std;

void test(int i) {
	cout << " The int is " << i << endl;
}
void test(double  f) {
	cout << " The float is " << f << endl;
}
void test(char const *ch) {
	cout << " The char* is " << ch << endl;
}

int main() {
	test(5);
	test(5.5);
	test("five");
	return 0;
}

आउटपुट:

कोड का स्क्रीनशॉट यहां दिया गया है:

Code स्पष्टीकरण:

1. हमारे कोड में iostream हेडर फ़ाइल शामिल करें। हम इसके फ़ंक्शन का उपयोग करने में सक्षम होंगे।
2. हमारे कोड में std नामस्थान शामिल करें। हम इसे कॉल किए बिना इसके क्लास का उपयोग कर सकेंगे।
3. test नामक एक फ़ंक्शन बनाएँ जो एक पूर्णांक पैरामीटर i लेता है। { फ़ंक्शन test के मुख्य भाग की शुरुआत को चिह्नित करता है।
4. यदि उपरोक्त फ़ंक्शन परीक्षण को लागू/बुलाया जाता है तो निष्पादित किया जाने वाला कथन।
5. उपरोक्त फ़ंक्शन परीक्षण के मुख्य भाग का अंत.
6. टेस्ट नामक एक फ़ंक्शन बनाएँ जो फ़्लोट पैरामीटर f लेता है। { फ़ंक्शन टेस्ट के मुख्य भाग की शुरुआत को चिह्नित करता है।
7. यदि उपरोक्त फ़ंक्शन परीक्षण को लागू/बुलाया जाता है तो निष्पादित किया जाने वाला कथन।
8. उपरोक्त फ़ंक्शन परीक्षण के मुख्य भाग का अंत.
9. टेस्ट नामक एक फ़ंक्शन बनाएँ जो एक वर्ण पैरामीटर ch लेता है। { फ़ंक्शन टेस्ट के मुख्य भाग की शुरुआत को चिह्नित करता है।
10. यदि उपरोक्त फ़ंक्शन परीक्षण को लागू/बुलाया जाता है तो निष्पादित किया जाने वाला कथन।
11. उपरोक्त फ़ंक्शन परीक्षण के मुख्य भाग का अंत.
12. main() फ़ंक्शन को कॉल करें। { फ़ंक्शन के मुख्य भाग की शुरुआत को चिह्नित करता है।
13. फ़ंक्शन टेस्ट को कॉल करें और तर्क के मान के रूप में 5 पास करें। यह टेस्ट फ़ंक्शन को आमंत्रित करता है जो एक पूर्णांक तर्क स्वीकार करता है, यानी पहला टेस्ट फ़ंक्शन।
14. फ़ंक्शन टेस्ट को कॉल करें और तर्क के मान के रूप में 5.5 पास करें। यह उस टेस्ट फ़ंक्शन को आमंत्रित करेगा जो फ़्लोट तर्क को स्वीकार करता है, यानी दूसरा टेस्ट फ़ंक्शन।
15. फ़ंक्शन टेस्ट को कॉल करें और तर्क के मान के रूप में पाँच पास करें। यह टेस्ट फ़ंक्शन को आमंत्रित करेगा जो एक वर्ण तर्क स्वीकार करता है, यानी तीसरा टेस्ट फ़ंक्शन।
16. यदि प्रोग्राम सफलतापूर्वक चलता है तो उसे एक मान अवश्य लौटाना चाहिए।
17. main() फ़ंक्शन के मुख्य भाग का अंत.

हमारे पास एक ही नाम वाले तीन फ़ंक्शन हैं लेकिन अलग-अलग प्रकार के तर्क हैं। हमने बहुरूपता हासिल कर ली है।

Operaटोर ओवरलोडिंग

In Operaटोर ओवरलोडिंग, हम एक के लिए एक नया अर्थ परिभाषित करते हैं C++ ऑपरेटरइससे ऑपरेटर के काम करने का तरीका भी बदल जाता है। उदाहरण के लिए, हम दो स्ट्रिंग को जोड़ने के लिए + ऑपरेटर को परिभाषित कर सकते हैं। हम इसे संख्यात्मक मानों को जोड़ने वाले जोड़ ऑपरेटर के रूप में जानते हैं। हमारी परिभाषा के बाद, जब इसे पूर्णांकों के बीच रखा जाता है, तो यह उन्हें जोड़ देगा। जब इसे स्ट्रिंग के बीच रखा जाता है, तो यह उन्हें जोड़ देगा।

उदाहरण 2

#include<iostream> 
using namespace std;

class ComplexNum {
private:
	int real, over;
public:
	ComplexNum(int rl = 0, int ov = 0) {
		real = rl;   
		over = ov; 
	}

	ComplexNum operator + (ComplexNum const &obj) {
		ComplexNum result;
		result.real = real + obj.real;
		result.over = over + obj.over;
		return result;
	}
	void print() { 
		cout << real << " + i" << over << endl; 
	}
};
int main()
{
	ComplexNum c1(10, 2), c2(3, 7);
	ComplexNum c3 = c1+c2;
	c3.print();
}

आउटपुट:

कोड का स्क्रीनशॉट यहां दिया गया है:

Code स्पष्टीकरण:

1. इसके कार्यों का उपयोग करने के लिए iostream हेडर फ़ाइल को हमारे प्रोग्राम में शामिल करें।
2. अपने प्रोग्राम में std नामस्थान को शामिल करें ताकि इसे कॉल किए बिना इसके क्लासों का उपयोग किया जा सके।
3. ComplexNum नामक एक क्लास बनाएँ। { क्लास बॉडी की शुरुआत को चिह्नित करता है।
4. चरों को निजी के रूप में चिह्नित करने के लिए निजी पहुँच संशोधक का उपयोग करें, जिसका अर्थ है कि उन तक केवल वर्ग के भीतर से ही पहुँचा जा सकता है।
5. दो पूर्णांक चर, वास्तविक और ओवर को परिभाषित करें।
6. कंस्ट्रक्टर को पब्लिक के रूप में चिह्नित करने के लिए पब्लिक एक्सेस मॉडिफायर का उपयोग करें, जिसका अर्थ है कि यह क्लास के बाहर से भी एक्सेस किया जा सकेगा।
7. क्लास कन्स्ट्रक्टर बनाएं और वेरिएबल्स को आरंभीकृत करें।
8. चर real का मान आरंभ करें.
9. चर का मान आरंभ करें.
10. कन्स्ट्रक्टर बॉडी का अंत.
11. हमें + ऑपरेटर के अर्थ को ओवरराइड करने की आवश्यकता है।
12. ComplexNum प्रकार का डेटा प्रकार परिणाम बनाएँ.
13. सम्मिश्र संख्याओं के साथ + ऑपरेटर का उपयोग करें। यह रेखा एक संख्या के वास्तविक भाग को दूसरी संख्या के वास्तविक भाग में जोड़ देगी।
14. सम्मिश्र संख्याओं के साथ + ऑपरेटर का उपयोग करें। यह रेखा एक संख्या के काल्पनिक भाग को दूसरी संख्या के काल्पनिक भाग से जोड़ देगी।
15. प्रोग्राम सफल निष्पादन पर चर परिणाम का मान लौटाएगा।
16. + ऑपरेटर के नए अर्थ अर्थात ओवरलोडिंग की परिभाषा का अंत।
17. print() विधि को कॉल करें.
18. कंसोल पर जोड़ने के बाद नई जटिल संख्या प्रिंट करें।
19. print() फ़ंक्शन के मुख्य भाग का अंत.
20. ComplexNum वर्ग के मुख्य भाग का अंत.
21. main() फ़ंक्शन को कॉल करें.
22. जोड़ने के लिए वास्तविक और जटिल दोनों भागों के मान पास करें। c1 का पहला भाग c2 के पहले भाग में जोड़ा जाएगा, यानी 10+3। c1 का दूसरा भाग c के दूसरे भाग में जोड़ा जाएगा, यानी 2+7।
23. ओवरलोडेड + ऑपरेटर का उपयोग करके एक ऑपरेशन निष्पादित करें और परिणाम को वेरिएबल c3 में संग्रहीत करें।
24. कंसोल पर वेरिएबल c3 का मान प्रिंट करें।
25. main() फ़ंक्शन के मुख्य भाग का अंत.

जहां कंपाइल-टाइम पॉलीमॉर्फिज्म जल्दी निर्णय लेता है, वहीं दूसरी श्रेणी निष्पादन तक चुनाव को स्थगित कर देती है।

रनटाइम पॉलीमॉर्फिज़्म

ऐसा तब होता है जब किसी ऑब्जेक्ट की विधि को संकलन समय के बजाय रनटाइम के दौरान बुलाया/बुलाया जाता है। रनटाइम बहुरूपता फ़ंक्शन ओवरराइडिंग के माध्यम से प्राप्त की जाती है। कॉल/बुलाया जाने वाला फ़ंक्शन रनटाइम के दौरान स्थापित किया जाता है।

फंक्शन ओवरराइडिंग

फ़ंक्शन ओवरराइडिंग तब होती है जब बेस क्लास के फ़ंक्शन को व्युत्पन्न क्लास में एक नई परिभाषा दी जाती है। उस समय, हम कह सकते हैं कि बेस फ़ंक्शन को ओवरराइड कर दिया गया है।

उदाहरण के लिए:

#include <iostream>
using namespace std;
class Mammal {

public:
	void eat() {

		cout << "Mammals eat...";
	}

};

class Cow: public Mammal {

public:
	void eat() {

		cout << "Cows eat grass...";
	}
};
int main(void) {

	Cow c = Cow();

	c.eat();

	return 0;

}

आउटपुट:

कोड का स्क्रीनशॉट यहां दिया गया है:

Code स्पष्टीकरण:

1. इसके कार्यों का उपयोग करने के लिए iostream हेडर फ़ाइल को हमारे प्रोग्राम में आयात करें।
2. अपने प्रोग्राम में std नामस्थान को शामिल करें ताकि इसे कॉल किए बिना इसके क्लासों का उपयोग किया जा सके।
3. Mammal नामक एक क्लास बनाएँ। { क्लास बॉडी की शुरुआत को चिह्नित करता है।
4. हम जो फ़ंक्शन बनाने जा रहे हैं उसे सार्वजनिक रूप से सुलभ बनाने के लिए पब्लिक एक्सेस मॉडिफ़ायर का उपयोग करें। यह इस क्लास के बाहर से भी सुलभ होगा।
5. eat नामक एक सार्वजनिक फ़ंक्शन बनाएँ। { फ़ंक्शन बॉडी की शुरुआत को चिह्नित करता है।
6. जब फ़ंक्शन eat() को लागू किया जाता है तो cout फ़ंक्शन में जोड़ा गया कथन प्रिंट करें।
7. फ़ंक्शन eat() के मुख्य भाग का अंत.
8. स्तनपायी वर्ग के शरीर का अंतिम भाग।
9. गाय नामक एक क्लास बनाएँ जो Mammal क्लास को इनहेरिट करती है। Cow व्युत्पन्न क्लास है, जबकि Mammal बेस क्लास है। { इस क्लास की शुरुआत को दर्शाता है।
10. हम जिस फ़ंक्शन को बनाने जा रहे हैं उसे सार्वजनिक रूप से सुलभ के रूप में चिह्नित करने के लिए पब्लिक एक्सेस मॉडिफ़ायर का उपयोग करें। यह इस क्लास के बाहर से भी सुलभ होगा।
11. बेस क्लास में परिभाषित फ़ंक्शन eat() को ओवरराइड करें। { फ़ंक्शन बॉडी की शुरुआत को चिह्नित करता है।
12. जब यह फ़ंक्शन लागू किया जाता है तो कंसोल पर प्रिंट करने के लिए कथन.
13. फ़ंक्शन eat() के मुख्य भाग का अंत.
14. वर्ग गाय के शरीर का अंत.
15. main() फ़ंक्शन को कॉल करें। { इस फ़ंक्शन के मुख्य भाग की शुरुआत को चिह्नित करता है।
16. Cow क्लास का एक उदाहरण बनाएं और उसे c नाम दें।
17. Cow क्लास में परिभाषित eat() फ़ंक्शन को कॉल करें।
18. प्रोग्राम को सफलतापूर्वक पूरा होने पर एक मान लौटाना होगा।
19. main() फ़ंक्शन का अंत.

C++ आभासी कार्य

वर्चुअल फ़ंक्शन रन-टाइम बहुरूपता को लागू करने का एक और तरीका है C++यह एक विशेष फ़ंक्शन है जिसे बेस क्लास में परिभाषित किया गया है और व्युत्पन्न क्लास में पुनः परिभाषित किया गया है। वर्चुअल फ़ंक्शन घोषित करने के लिए, आपको वर्चुअल कीवर्ड का उपयोग करना चाहिए। कीवर्ड को बेस क्लास में फ़ंक्शन की घोषणा से पहले होना चाहिए।

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

#include <iostream>  
using namespace std;
class ClassA {
		public:
		virtual void show() {
			cout << "The show() function in base class invoked..." << endl;
		}
	};
	class ClassB :public ClassA {
	public:
		void show() 	{
			cout << "The show() function in derived class invoked...";
		}
	};
	int main() {
		ClassA* a;   
		ClassB b;
		a = &b;
		a->show();      
	}

आउटपुट:

कोड का स्क्रीनशॉट यहां दिया गया है:

Code स्पष्टीकरण:

1. इसके फ़ंक्शन का उपयोग करने के लिए कोड में iostream हेडर फ़ाइल शामिल करें।
2. अपने कोड में std नामस्थान को शामिल करें ताकि उसे कॉल किए बिना उसकी क्लासों का उपयोग किया जा सके।
3. ClassA नामक एक क्लास बनाएं.
4. किसी वर्ग सदस्य को सार्वजनिक रूप से सुलभ के रूप में चिह्नित करने के लिए सार्वजनिक पहुँच संशोधक का उपयोग करें।
5. show() नाम से एक वर्चुअल फ़ंक्शन बनाएँ। यह एक सार्वजनिक फ़ंक्शन होगा।
6. शो() को लागू करने पर प्रिंट करने के लिए पाठ। endl एक है C++ कीवर्ड, जिसका मतलब है अंतिम पंक्ति। यह माउस कर्सर को अगली पंक्ति पर ले जाता है।
7. वर्चुअल फ़ंक्शन show() के मुख्य भाग का अंत.
8. क्लास ClassA के मुख्य भाग का अंत.
9. ClassB नामक एक नया वर्ग बनाना जो ClassA वर्ग को विरासत में लेता है। ClassA आधार वर्ग बन जाता है जबकि ClassB व्युत्पन्न वर्ग बन जाता है।
10. किसी वर्ग सदस्य को सार्वजनिक रूप से सुलभ के रूप में चिह्नित करने के लिए सार्वजनिक पहुँच संशोधक का उपयोग करें।
11. आधार वर्ग में व्युत्पन्न वर्चुअल फ़ंक्शन show() को पुनः परिभाषित करें।
12. व्युत्पन्न वर्ग में परिभाषित show() फ़ंक्शन को लागू करने पर कंसोल पर मुद्रित होने वाला पाठ।
13. show() फ़ंक्शन के मुख्य भाग का अंत.
14. व्युत्पन्न वर्ग, ClassB के मुख्य भाग का अंत.
15. main() फ़ंक्शन को कॉल करें। प्रोग्राम लॉजिक को इसके बॉडी में जोड़ा जाना चाहिए।
16. a नाम से एक पॉइंटर वैरिएबल बनाएँ। यह ClassA नाम की क्लास की ओर इशारा करता है।
17. ClassB नामक क्लास का एक इंस्टेंस बनाएँ। इंस्टेंस को b नाम दिया गया है।
18. पता b में संग्रहीत मानों को चर a में निर्दिष्ट करें।
19. व्युत्पन्न वर्ग में परिभाषित show() फ़ंक्शन को लागू करें। लेट बाइंडिंग को लागू किया गया है।
20. main() फ़ंक्शन के मुख्य भाग का अंत.

दोनों तंत्रों को कवर करने के बाद, नीचे दी गई तालिका उनकी तुलना साथ-साथ करती है।

संकलन-समय बहुरूपता बनाम रन-समय बहुरूपता

इन दोनों के बीच प्रमुख अंतर इस प्रकार हैं:

अक्सर पूछे जाने वाले प्रश्न