Protected Inheritance

Protected Inheritance भी Private Inheritance के समान ही है। ये दोनों ही Inheritances एक Composition या “Has A” Relationship को Represent करते हैं। लेकिन एक Protected Derived Class के Member Functions Base Class के Protected व Public Member Functions को Access कर सकते हैं। जबकि Private Inheritance से Derived Class के Member Functions ऐसा नहीं कर सकते हैं। यदि Accessibility व विभिन्न प्रकार के Inheritances का सारांश निकालें इस सारांश को निम्न सारणी के अनुसार Represent किया जा सकता है:

ये सारणी बताती है कि किस प्रकार से Inherited Derived Class के Member Functions, Base Class के Members को Access कर सकते हैं। Private Members कभी भी Access नहीं किए जा सकते हैं और Private Inheritance सभी Member Functions को Inaccessible बना देता है। सारणी निम्नानुसार है:

इस Table के अलावा एक और Table निम्नानुसार है जो ये बताता है कि Derived Class के Objects जो कि Class Specification से बाहर जैसे कि main() में Define किए गए हैं, Base Class के किन Members को Access कर सकते हैं। केवल Public तरीके से Derive किए गए Public Members ही Accessible होते हैं।

Inheritance दो Level से ज्यादा का भी हो सकता है। जैसे Alpha Class से Beta Class को Derive किया जा सकता है। फिर Beta Class से Gamma Class को Derive किया जा सकता है। इसी तरह से Gamma Class से delta Class को Derive किया जा सकता है। यानी हम किसी भी Class को किसी भी Level तक Derive कर सकते हैं। जैसे:

	class alpha                  	// first generation Level
	{  };

	class beta : public alpha    	// second generation Level
	{  };

	class gamma : public beta    	// third generation Level
	{  };

	class delta : public gamma   	// fourth generation Level
	{  };

इस Code Segment से समझें तो जो Relationship alpha व beta Class के बीच है वही Relationship gamma व delta Class के बीच भी है।  एक Class उसकी सभी पिछली Base Classes को Access कर सकता है। यानी Public Inheritance में Delta Class के Member Functions gamma Class के Protected व public Members को Access कर सकते हैं। साथ ही ये beta व alpha Class के भी Public व Protected Members (Data Members व Member Functions) को Access कर सकते हैं। जबकि ये स्वयं की Class को छोडकर किसी भी अन्‍य Class के Private Data को Access नहीं कर सकते हैं। जब किसी Class Hierarchy में दो से अधिक Level होते हैं तब Constructors को Handle करना और अधिक कठिन काम हो जाता है। निम्न Program में इस प्रकार के Constructor को दर्शाया गया है।

	#include <iostream.h>
	class Gparent
	{
		private:
			int intv;
			float flov;
		public:
			Gparent(int i, float f) : intv(i), flov(f) 	// Initialize Gparent
			{  }
      
			void display()
			{ 
			cout << intv << ", " << flov << "; "; 
			}
	};

	class Parent : public Gparent
	{
		private:
			int intv;
			float flov;
		public:
			Parent(int i1,float f1,int i2,float f2):Gparent(i1, f1), // Initialize Gparent
			intv(i2), flov(f2)                 			// Initialize Parent
			{  }
			void display()
			{
			Gparent::display();
			cout << intv << ", " << flov << "; ";
			}
	};

	class Child : public Parent
	{
	private:
		int intv;
		float flov;
	public:
		Child(int i1, float f1,int i2, float f2, int i3, float f3) :
		Parent(i1, f1, i2, f2),            	// Initialize Parent
		intv(i3), flov(f3)                 	// Initialize Child
	{  }

	void display()
	{
		Parent::display();
		cout << intv << ", " << flov;
	}
	};
	void main()
	{
		Child ch(1, 1.1, 2, 2.2, 3, 3.3);
		cout << "\nData in ch = ";
		ch.display();
	}

इस Program में एक Parent Class से Child Class को Inherit किया गया है, जबकि Parent Class स्वयं Gparent Class से Inherited है। हर Class में एक int व एक float प्रकार का Data Item है। हर Class में एक Constructor अपनी व अपने सभी Base Class के Data को Initialize करने के लिए Data Accept करता है।  इसका मतलब ये हुआ कि Gparent Class के Data को Initialize करने के लिए, दो Argument फिर Parent Class के Data को Initialize करने के लिए दो Arguments यानी कुल चार Arguments और यदि स्वयं Child Class को Initialize करने के लिए दो Argument यानी कुल 6 Arguments इस Child Class के Object को प्रदान करने पडते हैं। हर Class का Constructor अपने Base Class के Constructor को Call करता है जो कि वापस उसके स्वयं के Base Class के Constructor को Call करता है। main() Function में हमने Child Class का एक Object Create किया है और उसे 6 Arguments प्रदान किए है और अन्त में उस Object के Data को Display किया है। इसका Output निम्नानुसार प्राप्त होता है:

      Data in ch = 1, 1.1; 2, 2.2; 3, 3.3

इससे पहले कि Child Class का Constructor Execute होना शुरू हो, Child Class का Object ch व Child Object का Parent Class का Subobject तथा Parent Class के Base Class का Sub-object ये सभी Initialize होते हैं। इसीलिए Child Class के Object को 6 Arguments प्रदान किए गए हैं।  इससे पहले कि Constructor का Opening Braces Execute हो, ये सभी Initialization होने जरूरी होते हैं। इसलिए जब हमारे Program के Child Class का Constructor Execute होना शुरू होता है, तो हम निश्चित रूप से कह सकते हैं कि सभी Objects व Sub-object Create व Initialized हो चुके हैं। परिणामस्वरूप हम जब किसी Initializer List में Derived Class के Base Class के Constructor को Call कर रहे होते हैं, तब हम किसी Generation को Skip नहीं कर सकते हैं। हमें सभी Generation के Data Items को Initialize करना ही पडता है। यदि हम निम्नानुसार Child Constructor Call करें:

Child(int i1, float f1, int i2, float f2, int i3, float f3) :
   Gparent(i1, f1),       // error: can't initialize Gparent
   intv(i3), flov(f3)     // initialize Child
   {  }

तो यहां पर Gparent Class के Constructor को Call करना गलत है क्योंकि Child Class की Base Class Gparent Class नहीं बल्कि Parent Class है। यदि हम इस अध्‍याय के अभी तक के विवेचन का सारांश निकालें तो कह सकते हैं कि:

1. Private Data को उसके Class के बाहर कभी भी Directly Access नहीं किया जा सकता है।
2. Private Inheritance से Base Class के सभी Data Derived Class के लिए Inaccessible हो जाते हैं।
3. Protected Inheritance से Base Class के Private व Public Data Members को उसी Class के Inherited Derived Class का कोई भी Member Access कर सकता है। फिर इस बात से कोई फर्क नहीं पडता है कि किस प्रकार के Inheritance Technique का प्रयोग किया गया है।
4. Base Class के Protected Members उन सभी Derived Classes में Accessible होते हैं जिन्हें Public या Protected Form में Derive किया गया है।
5. एक ऐसा Object जो कि Derived Class का है और Class Hierarchy से Outside में Define किया गया है, Base Class के Members को केवल तभी Access कर सकता है जब Base Class के Members Public हों और Base Class से Public Inheritance से Derive हुए हों। यहां तक कि सभी Derivation Public होने चाहिएं। यदि एक भी Generation में Public Derivation नहीं हुआ तो Base Class के Members को Access नहीं किया जा सकता है।