C++ Friend Class

C++ Friend Class: Functions की तरह Classes को भी friend बनाया जा सकता है। एक friend Class को Use करने का एक सामान्‍य कारण Interclass से Communication प्राप्त करना होता है।

C++ Friend Class: Interclass Communication

मानलो कि हमारे पास alpha व beta दो Classes हैं जो कि एक दूसरे से Closely Associated हैं। वास्तव में ये दोनों Classes इतने Closely Associated हैं कि एक दूसरे के Private Data को बिना public Access Specifier के Directly Access कर सकते हैं।

चूंकि हम Data को Public नहीं रखते हैं क्योंकि ऐसा करने पर कोई भी Function उन Data को Mistake से Change कर सकता है। साथ ही एक Class दूसरी Class के प्रकार की (Kind of) नहीं होती है, इसलिए हम इन्हें Inheritance द्वारा भी Relate नहीं कर सकते हैं। अब हम एक Class के Private Members को दूसरी Class में किस प्रकार से Access कर सकते हैं। तो इस सवाल का जवाब है कि हम friend Classes के द्वारा ऐसा कर सकते हैं।

Interclass Communication में एक समस्या ये होती है कि किस Class Specification को पहले Create किया जाए। हम उस Class के Members को तब तक किसी Class में Specify नहीं कर सकते हैं जब तक कि उस Class को Specify ना किया जाए, क्योंकि Compiler उस Class के बारे में कुछ भी नहीं जानता है। यदि alpha को beta से पहले Specify कर दिया जाए, तो beta Class के Member Functions से alpha Class के Private Data को Access किया जा सकता है लेकिन alpha Class के Member Functions beta Class के Private Data को Access नहीं कर सकते हैं। इस समस्या का समाधान ये है कि Class beta को Class alpha का friend बना दिया जाए।

	// a class accesses data in a previously-defined class
	#include <iostream.h>

	class alpha
	{
		private:
			friend class beta;           	// so beta can access alpha data
			int adata;                   	// alpha's private data
	};

	class beta
	{
		public:
			void bfunc()
			{
				alpha objA;               	// make an object to
				objA.adata = 3;           	// access private alpha data
			}
	};

ये Statement beta Class के किसी भी Member Function को ये सुविधा प्रदान कर देता है कि वह alpha Class के Private व Protected Data Members को Access कर सकता है।

ध्‍यान दें कि friend व class दोनों Keywords का प्रयोग करना जरूरी है। friend Functions की तरह ही Compiler को इससे कोई फर्क नहीं पडता है कि ये Declaration Class में कहां Declare किया गया है, लेकिन सैद्धांतिक रूप से इस Declaration को Private Part में करना ही उचित रहता है, क्योंकि alpha व beta के बीच का Friend Connection केवल इन्ही दोनों Classes के बीच होता है। ये Public Interface का Part नहीं हैं, जिन्हें Class User Access कर सके।

ये बात हमेंशा ध्‍यान रखनी चाहिए कि एक Class का Member किसी दूसरे Class के Data को Abstract तरीके से Access नहीं कर सकता है। जैसे

alpha ::adata = 12;

ये Statement एक Error Generate करेगा क्योंकि ऐसा करने के लिए एक Object की जरूरत होती है। ऐसा हम तब कर सकते हैं जब beta को alpha Class से Derive किया गया हो। ये दोनों अलग Classes हैं और friendship family के समान नहीं होती है। यानी इस Statement को एक Actual Object या किसी Actual Object के Pointer की जरूरत होती है, जिसके अन्दर Data रहता है। यानी हम इसे निम्नानुसार Access कर सकते हैं:

alpha objA;

objA.adata = 21;

मानलो कि alpha Class का एक Member Function beta Class के Private Data को Access करना चाहता है। ये एक तरह की समस्या है क्योंकि alpha Class को beta Class से पहले Specify किया गया है और Compiler को पहले वह Class बतानी होती है। जिसके Members को Access करना है। यदि हम beta Class को पहले Specify कर दें तो beta Class के सम्बंध में भी यही समस्या पैदा हो जाती है।

इस स्थिति को सुलझाने का तरीका ये है कि alpha Class के एक Function afunc() को alpha Class से बाहर और beta Class के बाद Define करें। इसे हम निम्नानुसार Code Segments द्वारा समझ सकते हैं:

	// class accesses data in a not-yet-defined class
	class alpha
	{
	   public:
		  void afunc();                	// function declaration
	};                              		// (definition must follow beta)

	class beta
	{
	   private:
		  friend class alpha;          	// so alpha can access beta data
		  int bdata;                   	// beta's data
	};

	void alpha::afunc()                	// alpha's function
	{
	   beta objB;                      	// create beta object
	   objB.bdata = 3;                 	// access its private data
	};

हमने alpha Class के एक Function को beta Class की Specification के बाद Define किया है। इससे Compiler जब afunc() को Compile करने के लिए उसकी Definition पर जाता है, तो उसे पता चल जाता है कि beta क्या है। इसलिए Compiler उन Statements को Handle करने में सक्षम हो जाता है, जिनसे beta Class के Private Data को Access किया जा रहा है। फिर ध्‍यान दें कि ये Data केवल किसी Actual Object के अन्दर ही होने जरूरी होते हैं।

C++ Friend Class: Pointers in Interclass Communication

किसी Real Program में जब एक Class का Data दूसरी Class में Access किया जाता है, तब Object को Refer करने के लिए सबसे Common तरीका Pointers to Object होता है। अगला उदाहरण ना केवल ये Show करता है, कि Objects को Pointers के द्वारा कैसे Access किया जा सकता है। बल्कि एक 2-Way Communication को भी Demonstrate करता है, जिसमें alpha Class beta Class के Private Member को Access कर रहा है और beta Class alpha Class के Private Members को Access कर रहा है।

Interclass Communication के लिए Pointers का प्रयोग करने का Concept ये है कि हर Class में दूसरी Class के Object का Pointer होता है। Interclass Communication में दो Classes के विभिन्न Objects होते हैं।

हमारे उदाहरण में हम ये मान रहे हैं कि हर alpha Class Object एक beta Class Object से Associated है। इसमें alpha Class में beta Class के दो Pointers हैं ताकि alpha beta Class के Data को Access कर सके और beta Class में alpha Class का एक Pointer है ताकि beta alpha के Data को Access कर सके। साथ ही दोनों Classes को एक दूसरे का Friend Declare किया गया है।

// Program
// interclass communication using pointers and friend classes
	#include <iostream.h>
	#include <conio.h>

	class alpha                    		// an alpha is associated with
	{                           		// several betas
		private:
			friend class beta;      // for beta access to alpha data
			beta* bptr1;            // pointers to betas
			beta* bptr2;
			int adata;

		public:
			alpha();                // constructor (defined after beta)
			void afunc();           // function (defined after beta)
	};

	class beta                     		// several betas are
	{                           			// associated with an alpha
		private:
			friend class alpha;     // for alpha access to beta data
			alpha* aptr;            // pointer to "our" alpha
			int bdata;              // data

			// note: constructor is private
			beta(alpha* ap) : aptr(ap)  	// 1-arg construtor
			{  }
						// initializes pointer to alpha
		public:
			void bfunc()
			{
				aptr->adata = 3;// access private alpha data
			}
	};

	alpha::alpha()                 	// alpha constructor
	{                           	// (must be defined after beta)
		bptr1 = new beta(this); // make betas
		bptr2 = new beta(this);
	}

	void alpha::afunc()            	// alpha function
	{
					// (must be defined after beta)
		bptr1->bdata = 4;       // accesses private beta data
		bptr2->bdata = 5;
	}

	void main()
	{
		alpha objA;
		objA.afunc();
		getch();
	}

हमने alpha Class के एक Member Function को beta Class के बाद Specify किया है क्योंकि alpha Class  के Constructors व beta afunc() Function दोनों को beta Class के Objects की जरूरत है। हम देख सकते हैं कि alpha Class का afunc() beta Class के Object के bdata को Access करता है और beta Class का bfunc() alpha Class के Object के adata को Access करता है।

मानलो कि Class का User केवल alpha Class के Object को ही Create करता है। यदि User beta Class के Object Create करता है, तो दो beta Class के Objects व एक alpha Class के Object दोनों को अलग किया जा सकता है। ये तय करने के लिए कि User beta Class का Object Create ना कर सके, हमें beta Class के Constructors को Private रखना होगा। इस स्थिति में beta का friend ही beta को Create कर सकता है।

जब एक alpha Object Create किया जाता है तब इसका Constructor दो beta Object Create करता है। ये ऐसा beta Class के Constructor को Call करके व उसमें this Pointer को Pass करके करता है। परिणामस्वरूप हर beta Object उससे Associated Alpha Object को Locate कर सकता है। क्योंकि alpha Class का Constructor new Operator का प्रयोग करके दो beta Objects Create करता है और उन्हें Pointers के द्वारा Access करता है। यानी हर Object जानता है कि दूसरा Object कहां है। (C++ Friend Class – CPlusPlus)