C++ Polymorphism using Reference

C++ Polymorphism: एक साधारण उदाहरण की तरह Polymorphism को User Code से Classes को Decouple करने के लिए मान लेते हैं कि एक Base Class की कई Derived Classes हैं और main() Function एक Global Nonmember Function func() को Call करता है, जो कि सभी Derived Classes के Objects के साथ कोई प्रक्रिया करता है।

यदि func() Function को विभिन्न प्रकार के Objects के साथ विभिन्न प्रकार की प्रक्रिया करने के लिए Code किया जाए, तो func() Function काफी Complicated हो जाएगा। लेकिन Virtual Functions व References का प्रयोग करके हम विभिन्न Classes के लिए func() Function के कई Versions Create कर सकते हैं।

जब किसी Object को By Reference Function में Pass किया जाता है, तब Use होने वाला Syntax ये दर्शाता है कि स्वयं Object Function में Pass हो रहा है, लेकिन वास्तव में Object का एक Pointer Function में Pass होता है।

जैसाकि हमने पहले भी देखा है कि Pointers हमेंशा समान Size के होते हैं, चाहे वे किसी भी Class के Object को Point क्यों ना कर रहे हों,  इसलिए यदि हम Derived Class Object का Reference उस Function में Pass करते है, जो कि Base Class के Object का Reference लेना चाहता है, तो भी Derived Class के Object की किसी Information का Loss नहीं होता है।

हमारे उदाहरण मे एक BaseClass है और दो Derived Classes DerivedClass1 व DerivedClass2 हैं। main() Function का Statement func() में DerivedClass1 व DerivedClass2 के Objects को By Reference Pass करते हुए Call करता है। ध्‍यान दें कि इस उदाहरण में func() नाम का एक ही Function दोनों Derived Classes के Objects को Handle कर रहा है। ये उदाहरण निम्नानुसार है:

	// Tests Virtual Functions and Passing Objects by Reference
	#include <iostream.h>
	#include <conio.h>

	class BaseClass
	{

		public:
			virtual void speak()
			{ cout << “\nBaseClass speaks"; }
	};

	class DerivedClass1 : public Base
	{

		public:
			void speak()
			{ cout << “\nDerivedClass1 speaks"; }
	};

	class DerivedClass2 : public Base
	{
		public:
			void speak()
			{ cout << “\nDerivedClass2 speaks"; }
	};

	void main()
	{
		void func(Base&);     	// prototype
		DerivedClass1 d1;          // create derived class object d1
		DerivedClass2 d2;          // create derived class object d2
		func(d1);             	// pass d1 by reference to func()
		func(d2);             	// pass d2 by reference to func()
		getch();
	}

	void func(Base& obj)     	// (note reference argument)
	{
		obj.speak();
	}

Func() Function उस Object को जिसका Reference func() Function में भेजा गया है, ये कहता है कि वह अपने speak() Member Function को Call करे जो कि ये Display करता है कि वह Object किस Class का है। इस Program का Output निम्नानुसार प्राप्त होता है:

// Output
   DerivedClass1 speaks
   DerivedClass2 speaks

चूंकि func() Function में Argument को By Reference भेजा गया है और speak() Member Function Virtual है, इसलिए func() Function को ये जानने की जरूरत नहीं है कि उसमें किस Class का Object Function speak() Message भेज रहा है। ये जानता है कि Object को BaseClass से Derived किया गया है, लेकिन इसे इतना ही जानना काफी है। Object स्वयं ये तय करता है कि उसे किस speak() Member Function को Call करना है, जैसाकि Output में देखा जा सकता है।

मानलो कि Polymorphism को Use नहीं किया गया है और func() Function को ही ये तय करना है कि वह किस प्रकार के Object के साथ प्रक्रिया कर रहा है। इस स्थिति में विभिन्न Classes को Handle करने के लिए या तो func() Function में एक लम्बे switch Statement का प्रयोग करना पडेगा और ये पता लगाना पडेगा कि Object किस Class का है या फिर main() Function को func() Functions के विभिन्न Versions में से Appropriate Version Class के आधार पर speak() को Choose करना होगा। ये दोनों ही समाधान अनावश्‍यक रूप से Complicated हैं।

कोई Object किस Message (Function) को Response करेगा, ये बात यदि Object पर ही छोड दी जाए, तो हम Use होने वाली Actual Class से User Code को अलग कर सकते हैं, जिससे User Code काफी सरल हो जाएंगे।

इस Approach का एक फायदा ये होगा कि समान User Codes का प्रयोग उन विभिन्न प्रकार की Classes के साथ भी किया जा सकता है, जिन Classes के लिए उन User Code को लिखा ही नहीं गया होता है। उदाहरण के लिए यदि हम इसी उदाहरण की Class Hierarchy में एक और DerivedClass3 Add करें, तो func() Function इस Class के Objects के साथ भी उसी प्रकार से समान रूप से प्रक्रिया कर सकता है जिस प्रकार से DerivedClass1 व DerivedClass2 के Objects के साथ करता है।

निश्चित रूप से ये Decoupling Effect तभी काम करता है जब हम Reference या Pointer Arguments का प्रयोग करते हैं। यदि हम किसी Derived Class Object के Reference या Pointer के स्थान पर स्वयं Object को Function में Pass करते हैं, तो वह Object Base Class की Size के अनुसार टुकडों में बंट जाएगा, क्योंकि Base Class का Object हमेंशा Derived Class के Objects से Size में छोटा होता है। साथ ही जब हम किसी Function में Derived Class Object के Reference या Pointer को Pass करते हैं, तब हमें Virtual Function का भी प्रयोग करना जरूरी होता है।

हमारे उदाहरण में यदि speak() Member Function Virtual ना हो, तो इस उदाहरण Program का Output कुछ निम्नानुसार होगा:

// Output
[
  BaseClass speaks
  BaseClass speaks
]

C++ में Polymorphism Virtual Functions पर निर्भर होता है। हालांकि इस उदाहरण में हमने Polymorphism का प्रयोग करके कुछ विशेष प्राप्त नहीं किया है, लेकिन एक बडे Program में जिसमें कई Derived Classes व कई Class-User Code Functions होते हैं, तब ये तरीका इन Functions के लिए काफी Efficient होता है, जिसमें Function को Base Class के आधार पर Develop किया जाता है ना कि कई Derived Classes के लिए। (C++ Polymorphism – CodingUnit)