Overloading Bracket Operator

Overloading Bracket Operator: इस Operator का प्रयोग सामान्‍यतया Array के Elements को Access करने के लिए किया जाता है। हम इसे Overload करके किसी Array के काम करने के तरीके को Modify कर सकते हैं।  जैसे यदि हम चाहें कि हम एक ऐसा Safe Array Create करें जो स्वयं Automatically Array की Bounding को Check करे ताकि हम उसकी Limit से अधिक Data उसमें Store ना कर सकें। तो इस काम के लिए हम इस Operator को Overload कर सकते हैं। एक ऐसा Function जो Reference Return करता है, हम उसे निम्नानुसार Left Side में Use कर सकते हैं:

function() = 21;

हमारा अगला Example Program एक safeArray Class Create करता है जिसमें सिर्फ एक ही Integer प्रकार का एक Array Data Member है। इस Program में access() Function Index Number के रूप में Array के किसी Data Element को Access करने के लिए केवल एक ही Argument लेता है।  ये Function Check करता है कि क्या वह Index Argument Array की Bounding Limit को Satisfy करता है या नहीं। यदि Argument Index Array की Limit में होता है तो इस बात पर निर्भर करते हुए कि Equal To Sign का प्रयोग किस Side में किया गया है, उस Index Number पर एक नया मान Store कर दिया जाता है या उस Index Number से मान को प्राप्त कर लिया जाता है।

main() Function एक Safe Array Create करके उसमें मानों को Fill करता है और Class को Test करता है तथा Array के मानों को Output में Display करके ये निश्चित करता है कि Array ठीक तरीके से काम कर रहा है या नहीं। इसका Program निम्नानुसार है:

// Program
	Class Definition
	#include <iostream.h>
	#include <process.h>                 	// for exit()
	#include <conio.h>

	class safeArray
	{
		private:
			enum {SIZE=100};               	// array size
			int arr[SIZE];                 	// ordinary array
		public:
			int& access(const int& n);     	// function declaration
	};

		int& safeArray::access(const int& n)  	// access() function
		{                                 	// returns by reference
			if( n< 0 || n>=SIZE )
			{ cout << "\nIndex out of bounds"; exit(1); }
			return arr[n];  	// return the value by reference
		}//Class Implementation

	void main()
	{
		int j;
		int temp;
		safeArray sa;                     	// make a safe array
		const int LIMIT = 20;            	// amount of data

		for(j=0; j<LIMIT; j++)           	// insert elements
			sa.access(j) = j*10;          	// *left* side of equals

		for(j=0; j<LIMIT; j++)           	// display elements
		{
			temp = sa.access(j);          	// *right* side of equals
			cout << "\nElement " << j << " is " << temp;
		}
		getch();
	}

// Output
  Element 0 is 0
  Element 1 is 10
  Element 2 is 20
  Element 3 is 30
  Element 4 is 40
  Element 5 is 50
  Element 6 is 60
  Element 7 is 70
  Element 8 is 80
  Element 9 is 90
  Element 10 is 100
  Element 11 is 110
  Element 12 is 120
  Element 13 is 130
  Element 14 is 140
  Element 15 is 150
  Element 16 is 160
  Element 17 is 170
  Element 18 is 180
  Element 19 is 190

main() Function में निम्न Statement j*10 मान को Array के विभिन्न Elements  arr[j] पर Store करता है जो कि Function का Return Value होता है। यहां Function को Operator के Left Side में लिखा गया है। यानी

sa1.access(j) = j*10;

और

temp = sa.access(j);

ये Statement arr[j] की Values को temp में Assign करता है, क्योंकि यहां पर Function Assignment Operator के Right Side में Use किया गया है। Program का Output दिखाता है कि Program ठीक तरीके से काम कर रहा है।

यदि Argument के रूप में दिया जाने वाला Index Number Array की Bounding से बाहर हो तो access() Function एक Error Message Display करता है। इसे Check करने के लिए हम यदि LIMIT को 90 कर दें, तो Compiler हमें Error देता है, जिसे हम Program को Compile करते समय देख सकते हैं। जैसे ही Error Generate होता है, exit() Function Execute होता है और Program Control Program से बाहर आ जाता है।

Access() function ठीक तरह से काम करता है लेकिन यदि Index Number को Argument के रूप में () में देने के बजाय यदि [] में दिया जाए, तो एक Programmer के लिए इसे समझना ज्यादा सरल होता है। इस स्थिति में हमें {} Operator को operator[ ]() Function द्वारा Overload करना होता है। इसे Overload करने पर हम निम्न Statement

Temp = sa.access(j) ;

को निम्नानुसार भी लिख सकते हैं:

temp = sa.operator[](j);

चूंकि हमें “C++” ये सुविधा देता है कि हम operator Keyword व Function के Parenthesis को भी छोड सकते हैं, इसलिए हम इस Statement को निम्नानुसार भी लिख सकते हैं:

temp = sa[j];

चूंकि operator[]() Function को By Reference Return करवाना है, इसलिए हम इसे Equal To Sign के Left में भी Use कर सकते हैं। इसे समझने के लिए निम्न Program देखते हैं:

// Program
#include <iostream.h>
#include <process.h>               	// for exit()
#include <conio.h>

class safeArray
{
	private:
		enum {SIZE=100};             // array size
		int arr[SIZE];               // ordinary array
	public:
		int& operator [](int n);     // function declaration
};

int& safeArray::operator [](int n)  	// overloaded []
{                               	// returns by reference
	if( n< 0 || n>=SIZE )
	{ cout << "\nIndex out of bounds"; exit(1); }
	return arr[n];
}

void main()
{
	int j;
	int temp;
	safeArray sa;                     	// make a safe array
	const int LIMIT = 20;            	// amount of data

	for(j=0; j<LIMIT; j++)           	// insert elements
		sa[j] = j*10;                 	// *left* side of equal sign

	for(j=0; j<LIMIT; j++)           	// display elements
	{
		temp = sa[j];                 	// *right* side of equal sign
		cout << "\nElement " << j << " is " << temp;
	}
	getch();
}  // end main()

इस Program में हम SafeArray में Input व Output के लिए निम्नानुसार Index Expression को Use कर सकते हैं:

sa[j] = j*10;

और

temp = sa[j];

ये दोनों Statements ठीक उसी प्रकार से Use किए गए हैं जिस प्रकार से कोई सामान्‍य Array Use किया जाता है। इस Program का Output भी बिल्कुल पिछले वाले Program की तरह ही प्राप्त होता है। (Overloading Bracket Operator – Subscript Operator Overloading – WikiBooks)