Constant Overloaded Operators

Constant Overloaded Operators: जब हमें किसी Object के मानों में किसी Function द्वारा कोई परिवर्तन नहीं करवाना होता है तब हम उस Object को const प्रकार का Declare करते हैं और const प्रकार के Objects को Access करने के लिए हमें const प्रकार के Member Function की ही जरूरत होती है।

जब हम किसी Binary Operator को Overload करते हैं तब ये उस Object के Data को Modify नहीं करते हैं जिसके Reference में इन्हें Call किया जाता है। इसी तरह से Unary + व – भी उस Object के Data को Change नहीं करते हैं जिसके Reference में इन्हें Call किया जाता है।

लेकिन = व += जैसे Assignment Operators उस Object के Data को Modify करते हैं, जिनके Reference में इन्हें Call किया जाता है। इसलिए हम किसी Function में इन्हें const Object की तरह नहीं भेज सकते हैं। Subscript Operator [] भी अपने Object को Modify करता है, इसलिए इसे भी const प्रकार से Function में Pass नहीं किया जा सकता है।

चलिए, एक Program देखते हैं जिसमें दो TTime Constant Object को आपस में जोडा जा रहा है। Program निम्नानुसार है:

Program
// overloads the + operator for TTime class,
// using const function
#include <iostream.h>
#include <conio.h>

class TTime
{
private:
	int hours;             	// 0 to 23
	int minutes;           	// 0 to 59
public:
                    			// no-arg constructor
	TTime() : hours(0), minutes(0) {  }
					// two-arg constructor
	TTime(int h, int m) : hours(h), minutes(m) {  }

	void display() const   // output to screen
	{
		cout << hours << ':' << minutes;
	}

	void get()             // input from user
	{
		char dummy;
		cout << "\nEnter time (format 12:59): ";
		cin >> hours >> dummy >> minutes;
	}
					// overloaded + operator
	TTime operator + (const TTime& right) const
	{
		TTime temp;       	// make a temporary object
		temp.hours = hours + right.hours;	// add data
		temp.minutes = minutes + right.minutes;
		if(temp.minutes >= 60)           	// check for carry
		{
			temp.hours++;
			temp.minutes -= 60;
		}
			return temp;            // return temporary object by value
	}
};  // end class TTime

void main()
{
	TTime Time1, Time2;
	const TTime noon(12, 0);             	// constant object

	cout << "Enter first TTime: ";
	Time1.get();
	Time2 = noon + Time1;                   // overloaded + operator adds Time1 to noon
	cout << "sum = ";
	Time2.display();	// display sum
	getch();
}

main() Function में TTime Object noon को const Declare किया गया है। निम्न Statement

Time2 = noon + Time1;

द्वारा Time1 के समय को noon में जोडा गया है। क्योंकि operator+() एक const Function है, इसलिए इसे एक const Object noon के Reference में Call किया जा सकता है। यदि operator const नहीं होता तो इसे const Object noon के Reference में Call करने पर Compiler एक Error Generate करता। ये तरीका एक Overloaded Operator को किसी const Object को Modify करने से रोकता है।

ध्‍यान दें कि operator+() Function चाहे const हो या ना हो निम्न Statement Normal तरीके से Execute होता है:

Time2 = Time1 + noon;

क्योंकि इस स्थिति में operator को एक Non – Constant Object Time1 के Reference में Call किया जा रहा है और इसमें Argument के रूप में noon को Pass किया जा रहा है जिसे पहले से ही एक const Object Declare कर दिया गया है। इसलिए इसके Data में किसी प्रकार का कोई परिवर्तन नहीं हो सकता है। जब एक Operator नया मान Produce करता है तो उस मान को Hold करने के लिए एक Object की जरूरत होती है।

उदाहरण के लिए उपरोक्त Program में operator+() Function इसके Argument Object के मान को स्वयं के मानों में जोडता है। उस जुडने वाले Resultant Sum को Hold करने के लिए एक Temporary Object की जरूरत होती है। सामान्‍यतया इसके लिए एक temp नाम के Object को Create किया जाता है।

चूंकि इस Temporary मान को एक temp Object में Store किया गया है, इसलिए इस मान को By Reference return नहीं किया जा सकता है। इसलिए इसे By Value Return करना पडता है, जैसाकि उदाहरण में किया गया है।

इसलिए कुछ अन्‍य Operators स्वयं के Object की Copy Return करते हैं, क्योंकि Resultant मान उसी Object में Store होता है जिसके Reference में operator को Call किया जाता है। ऐसा Assignment Operator व कुछ अन्‍य Operators के सम्बंध में होता है। मानलो कि alpha व beta दो Class Objects हैं और हम gama को निम्नानुसार प्राप्त करते हैं:

gama = alpha += beta;

तो operator+=() Function Object alpha के Reference में Call होता है alpha + beta का Result alpha को Assign होता है। Operation alpha += beta से प्राप्त होने वाला Return मान साधारणतया alpha में ही Store होता है और इसी का मान gama को प्राप्त होता है।

जब एक Object किसी Operator Function को स्वयं के Reference में Call करता है तब वह Function By Reference Result को Return कर सकता है। क्योंकि Object स्वयं तब भी उपलब्ध रहता है जब Function से Program Control Return होता है। Function के किसी Object की तरह Damage नहीं होता है। इस स्थिति में operator+=() Function By Reference Return हो सकता है जबकि operator+() By Value ही Return हो सकता है।