Arithmetic Operator Overloading

Arithmetic Operator Overloading: आइये सबसे पहले हम + Operator को Overload करना सीखते हैं। यहां हम ये चाहते हैं कि TTime class के दो Objects को आपस में जोडने के लिये हम + Operator को ये क्षमता प्रदान करें ताकि वह समझ सके कि TTime Object क्या है और उसके Data Members को किस प्रकार से जोडना है। जिससे हम + Operator को निम्नानुसार Use करके दो TTime Objects को जोड सकें।

Time3 = Time1 + Time2;

इसे हम ठीक निम्नानुसार मान सकते हैं:

Time3 = Time1.sum(Time2);

+ Operator को ये क्षमता प्रदान करने के लिए, ताकि वह TTime class के Objects को आपस में जोड सके, या ये कहें कि किसी Operator को Overload करने के लिए हमे “C++” के एक और Keyword operator का प्रयोग करना पडता है। इस Keyword के साथ उस Operator के लिए एक Function लिखना होता है, जिसे Overload करना है।  यानी हम जो Function लिखते हैं, उसका कोई नाम नहीं होता बल्कि उसके नाम के स्थान पर एक Operator होता है। यहां हम + Operator को TTime class के लिये Overload कर रहे हैं, इसलिए इसका Declaration कुछ निम्नानुसार होता है:

TTime operator+(TTime right)
{
   // needs Function body
}

इस Function में प्रथम Data Type TTime, Function की Return Type बता रहा है, कि ये Function एक TTime प्रकार का मान Return करेगा। operator एक Keyword है और इसका प्रयोग किसी Operator को Overload करने के लिए ही किया जाता है। + चिन्ह यहां Overload होने वाला Operator है। Function Argument के रूप में TTime Object right में उस Object का मान आता है, जिसे + Operator द्वारा जोडना है। इस Member Function को हम दो TTime Objects को जोडने के लिये निम्नानुसार Define कर सकते हैं:

        Time3 = Time1.operator +(Time2);

यहां Dot Operator के बाद में operator+() Function को Use किया गया है। “C++” के Compiler में इस प्रकार की व्‍यवस्था की गई है कि यदि हम Object को Function Operator+ से जोडने वाले Dot व Keyword operator दोनों को छोड दें, तो स्वयं ही Compiler Overloaded + Operator के Member Function को ही Call कर लेता है। यानी यदि हम%

Time3 = Time1.operator+(Time2);

को केवल

Time3 = Time1 +(Time2);

ही लिखें, तो भी operator+() Member Function ही Call होता है और Time2 के मान को Time1 के मान में जोड कर Time3 में Store कर देता है। यदि यहां हम

Time3 = Time1 +(Time2);

 Statement में से Function के कोष्‍ठक को भी हटा दें, यानी

Time3 = Time1 + Time2;

कर दें तो भी Compiler को कोई फर्क नहीं पडता है।  “C++” के Compiler में ही ये विशेषता जोड दी गई है कि हम Overload किये जा रहे Operator के Member Function को केवल उस Operator के प्रयोग द्वारा ही Call कर सकते हैं। हमें Overloaded Operator के Member Function को Call करने के लिए पूरा Statement लिखने की जरूरत ही नहीं है। इस कारण से केवल + Operator को Use करने से operator+() Function Execute हो जाता है। इस प्रकार से हम किसी भी तरह की Class के Objects के लिए किसी भी Operator को Overload करके विभिन्न प्रकार की प्रक्रियाऐं कर सकते हैं। 

चलिए, एक Complete Program द्वारा + Operator की Overloading को समझते हैं। Class व Program निम्नानुसार है:

// Program
#include <iostream.h>
class TTime
{
   private:
	  int hours;               	// 0 to 23
	  int minutes;             	// 0 to 59

   public:
	  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;
	  }

	  // Member Function for overloaded + operator
	  TTime operator + (TTime right)
	  {
		 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;
		 }
		If(temp.hours >= 24)
		{
		   temp.hours – 24;
		}

		 return temp;     // return temporary Object
	  }
};  // end class TTime

void main()
{
   TTime Time1, Time2, Time3;
   cout << "Enter first TTime: ";
   Time1.get();
   cout << "Enter second TTime: ";
   Time2.get();

   Time3 = Time1 + Time2;       // overloaded + operator
                        	// adds Time2 to Time1
   cout << "sum = ";
   Time3.display();           	// display sum
}

इस main() Function में हम देख सकते हैं कि कितने सरल तरीके से दो TTime Objects के Time मानों को उसी प्रकार से जोडा गया है जिस प्रकार से दो Integer प्रकार के Variables के मानों को जोडा जाता है। Operator की Overloading के कारण ही ऐसा सम्भव हो सकता है।

इस Program में operator+() Member Function ठीक उसी प्रकार से काम करता है, जिस प्रकार से पिछले अध्‍यायों में addTime() Function काम करता था। ये Function hours व minutes को Add करता है और ये भी Check करता है कि क्या hours व minutes का मान क्रमश: 23 व 59 से ज्यादा हुआ है या नहीं। यदि hours का मान 23 से अधिक हो तो Resultant मान में से 24 घटा दिया जाता है और यदि Resultant Minutes का मान 59 से अधिक हो तो minutes में से 60 घटा दिया जाता है और hours को 1 घण्‍टा बढा दिया जाता है।

इस Program में आप देख सकते हैं कि Time1 Object के Reference में Operator+() Member Function Call किया गया है और इस Member Function में Time2 Object को Argument के रूप में Pass by Value भेजा गया है। Time1 Object को हम Dot Operator के प्रयोग से

Time1.operator+(Time2);

भी लिख सकते हैं। फिर Time1 के Data Members में Time2 के Data Members को जोड कर एक Temp Object को Return किया गया है। जब Program Control इस Member Function से Return होता है उस समय Time3 में temp Object के मान को Copy कर देता है।  चूंकि temp Object में दोनों time Values के Addition का Result होता है, इसलिए ये Resultant मान Time3 Object को Assign हो जाता है और हमें Resultant मान Time3 Object में प्राप्त हो जाता है, जिसे Output में Print कर दिया जाता है। इस प्रकार + operator को Overload करके TTime class के दो Objects को जोडा गया है।

चूंकि इस Program में हमने Object को By Value Function में भेजा है और Function में एक temp नाम का Local Object Create किया है, इसलिए ये तरीका ज्यादा Efficient नहीं कहा जा सकता। क्योंकि जब temp Object Create होगा, तब Constructor Call होगा और जब Function Terminate होगा, तब Destructor Call होगा और Object Destroy हो जाएगा। साथ ही ये Function By Value मान Return कर रहा है, इसलिए जब Program Control Function से Return होगा, तब Copy Constructor को भी Call होना पडेगा।

अभी हमने दो Integer प्रकार के मानों वाले Objects को जोडने के लिए + Operator को Overload किया है। इसी प्रकार से हम किसी Non-Numerical मानों जैसे कि किसी String को भी आपस में जोडने के लिए + Operator को Overload कर सकते हैं। जैसे हमारे पास एक Object में “Bal” व दूसरे Object में “Kishan” String हो, तो हम + Operator को Overload करके इन दोनों को जोड सकते हैं जिससे हमें “BalKishan” String प्राप्त हो सकता है। इस Resultant String को किसी दूसरे Object में Assign किया जा सकता है। इसे समझने के लिए निम्न Program देखते हैं:

// Program
#include <iostream.h>
#include <string.h>                  // for strlen(), strcpy(), etc.

class xString
{
   private:
	  enum {MAX=80};             // maximum length of xStrings
	  char str[MAX];             // ordinary C string

   public:
	  xString()                  // no-arg Constructor
	  { 
	 	strcpy(str, ""); 
	  }
      
	  xString( char s[] )        // 1-arg Constructor
	  {
	 	strcpy(str, s); 
	  }

	  void input()               // get string from user
	  {
		cin.get(str, MAX); 
	  }
    
	  void display()             // display string
	  {
	 	cout << str; 
	  }

	  // concatenate two strings
	  xString operator+(xString right)
	  {
		 xString temp;       // temporary xString
		 if(strlen(str) + strlen(right.str) < MAX-1)
		 {
			strcpy(temp.str, str);   	// Copy us to temp
			strcat(temp.str, right.str);  	// concatenate Argument
		 }
		 else
			cout << "\nError: xString too long" << endl;
        
		 return temp;   // return temporary
	  }
};

void main()
{
   xString s1("Greetings, ");
   xString s2, s3;           

   cout << "Enter your name: ";
   s2.input();                   // get s2 from user

   s3 = s1 + s2 + ".";          //concatenate period to s2, s2 to s1
   s3.display();                // display s3
}

इस Program में operator+() Member Function एक Temporary xString Object Create करता है, क्योंकि इसे String को Store करने के लिए कुछ Space चाहिए और ये Original String या इसके Arguments को Modify करना नहीं चाहता है।

ये सबसे पहले Check करता है कि Strings को जोडने के बाद जितनी Space की जरूरत String को Store करने के लिए होगी उतनी Space है या नहीं। फिर Object स्वयं के Data यानी String को strcpy() Library Function का प्रयोग करके temp नाम के Local Object में Store करता है और strcat() Library Function का प्रयोग करके Argument को temp Object में Concatenate करता है यानी जोडता है और Function के अन्त में temp Object के Resultant String को Return करता है।

main() Function में xString Object s1 को “Greetings” String से Initialize किया गया है और s2 के लिए दूसरी String User से Input के रूप में प्राप्त किया जाता है। इन्हें आपस में जोडा जाता है और Resultant String को s3 Object में Store किया जाता है। अन्त में s3 Object को Print कर दिया जाता है। s3 Object के मानों को Print करने पर हमें निम्नानुसार Output प्राप्त होता है:

Enter your name: Bal Kishan
Greetings, Bal Kishan.

जिस तरह से हमने + Operator को Overload करके Real World Object के साथ Access करने के लिए Use किया है, उसी तरह से हम अन्‍य Arithmetic Operators को भी Overload कर सकते हैं।

जब किसी Overloaded Operator को Call किया जाता है, तब Overloaded Operator के Left में वह Object होता है, जिसके Reference में Overloaded Operator के Member Function को Call किया जाता है और Operator के Right Side में वह Object होता है, जिसे Argument के रूप में Operator के Member Function में भेजा जाता है।

किसी Overloaded Operator के Member Function को Call करने पर यानी किसी Overloaded Operator को Use करने पर ना ही Call होने वाले Reference Object के Data में कोई परिवर्तन होता है ना ही Argument के रूप में Operator के Member Function में Pass होने वाले Object के Data के मान में कोई परिवर्तन होता है। यानी दोनों Objects के Data बिल्कुल सुरिक्षत रहते हैं। फिर भी हम विभिन्न प्रकार से इन Operators को Overload कर सकते हैं। इस उदाहरण में इन Overloaded Operators ने केवल Class प्रकार के मान ही Return किए हैं। हम इन Functions से विभिन्न प्रकार के मानों को Return करवा सकते हैं। (Arithmetic Operator Overloading – Wiki)