Unary Operator Overloading in C++ – Increment Operator

Unary Operator Overloading in C++: Unary Operator केवल एक Operand पर काम करते हैं। उदाहरण के लिए हम ( ++ ) या ( — ) Operators को लेते हैं। ये Operators किसी एक Variable के मान को ही Increase या Decrease करते हैं। इसी तरह से Not (!) Operator भी एक Unary Operator है जो केवल किसी एक Operator पर ही काम करता है।

Unary Operators किसी प्रकार का कोई Argument नहीं लेते हैं। हालांकि हम यहां पर जो उदाहरण ले रहे हैं, उनमें एक Argument का प्रयोग करेंगे। ये Operators उस Object पर काम करते हैं जिनके Reference में इन्हें Call किया जाता है।  साधारणतया ये Operators Object के Left Side में Appear होते हैं। जैसे !Object, –Object, ++Object आदि।

कई Operators केवल Object के Left Side में ही Use किए जा सकते हैं जबकि ++ व — Operators ऐसे Operators हैं जिन्हें किसी Object के Left व Right दोनों Side में Use किया जा सकता है। चलिए, हम कुछ Unary Operators की Overloading करना सीखते हैं।

Prefix Version of Operator ++

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

	   public:
		  TTime() : hours(0), minutes(0){  }	// no-arg Constructor
		  TTime(int h, int m) : hours(h), minutes(m){ 	 // 2-arg Constructor

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

		  TTime operator++ ()  	// overloaded prefix ++ operator
		  {
			 ++minutes;          	// increment this Object
			 if(minutes >= 60)  
			 {
				++hours;
				minutes -= 60;
			 }                	// return new value
 
			 return TTime(hours, minutes);
		  }
	};  // end class TTime

	void main()
	{
	   TTime Time1, Time2;         	// make two TTimes
	   Time1.get();                	// get value for one

	   ++Time1;                    	// increment it
	   cout << "\nTime1=";
	   Time1.display();            	// display result

	// Time1++;                    	// error: postfix

	   Time2 = ++Time1;              // increment again, and assign
	   cout << "\nTime2=";
	   Time2.display();            	// display assigned value
	   getch();
	}

इस प्रोग्राम में सामान्‍य तरीके से Increment करने का तरीका दिखाया गया है। इस Program में ++ Operator उस Object के minute को एक minute Increase करता है, जिसके लिए इसे Call किया जाता है। इस Program में किसी Object के मान को Pre-increment के रूप में Use किया गया है। इस Program को Run करने पर ये निम्नानुसार User से Interact करता है:

Enter time (format 12:59): 12:21

Time1=12:22
Time2=12:23

इस Program में हमने एक Line को Comment बनाया है। यदि हम इस Comment को Normal Statement में Convert करके Program को Recompile करें, तो Compiler हमें एक Error Message देता है।  क्योंकि हमने Operator को Pre Increment करने के लिए Define किया है। जबकि इस Statement में हमने Operator को Post Increment करने के लिए Use किया है। चलिए, हम एक और Program देखते हैं, जिसमें Post-Increment किया गया है।

Postfix Version of Operator ++

आपके दिमाग में ये बात आ सकती है कि किस प्रकार से Compiler Pre या Post Increment या Decrement को पहचानता है। इसका जवाब है, एक int प्रकार का Argument जो किसी प्रकार का कोई मान Accept नहीं करता है। ये Argument Compiler को केवल ये बताता है, कि Function Post Increment का काम करेगा या Post Decrement का काम करेगा। इसे निम्नानुसार लिखा जा सकता है:

TTime operator++ ()       // prefix version

TTime operator++ (int)    // postfix version

 सामान्‍यतया हम इस int प्रकार के Argument को Function में Pass नहीं करते हैं। हमें केवल Function के Parenthesis में int लिखना होता है। इसे समझने के लिए हम Post Increment Operator Overloading का एक Program देखते हैं जो कि निम्नानुसार है:

// Program
	#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) {  }

		  // 2-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;
		  }

		  TTime operator++ ()           	// overloaded prefix ++ operator
		  {
			 ++minutes;                   	// increment this Object
			 if(minutes >= 60)
			 {
				++hours;
				minutes -= 60;
			 }                          	// return incremented value
			  return TTime(hours, minutes);
		   }

		  TTime operator++ (int)         	// overloaded postfix ++ operator
		  {
			 TTime temp(hours, minutes); 	// save original value
			 ++minutes;                    	// increment this Object
			 if(minutes >= 60)
			 {
				++hours;
				minutes -= 60;
			 }
			  return temp;                 	// return old original value
		   }
	};  // end class TTime

	void main()
	{
	   TTime Time1, Time2;                  // make two TTime
	   Time1.get();                         // get value for one

	   Time2 = ++Time1;                     // increment it (prefix) and assign

	   cout << "\nTime2=";
	   Time2.display();                     // display result

	   Time2 = Time1++;                     // increment (postfix) and assign

	   cout << "\nTime1=";
	   Time1.display();                     // display incremented value

	   cout << "\nTime2=";
	   Time2.display();                     // display assigned value

	   getch();
	}

इस उदाहरण में हम देख सकते हैं कि Postfix operator++(int) Function Prefix operator++() Function की तुलना में अलग तरीके से व्‍यवहार करता है। Postfix Function को उसके Object की Original Value को ध्‍यान रखना होता है, ताकि वह Object को Increment कर सके और फिर Original Value को Return कर सके ना कि नए मान को Return करे। ये काम एक Temporary Variable temp को Create करके किया जाता है जिसमें Object की Original Value को Initialize किया जाता है। Object को Increment करने के बाद temp को Return किया जाता है। इस Program का Output  निम्नानुसार प्राप्त होता है:

Enter time (format 12:59): 12:32

Time2=12:33
Time1=12:34
Time2=12:33

User Time1 Object के लिए Time Input करता है। Program इस Time को Prefix Operator के प्रयोग द्वारा Increment करता है, इसके मान को Object Time2 में Assign करता है और Time2 Object के मान को Display करता है।  चूंकि, Time1 Object का मान Time2 को Assign होने से पहले Increase हो चुका होता है, इसलिए Time2 Object नए Time 12:34 को Display करता है। इसके बाद Program Time1 को फिर से Increment करता है लेकिन इस बार Postfix Operator द्वारा Increment करता है और इसका मान Time2 Object को Assign करता है।  चूंकि इस बार इसका मान Increment होने से पहले Assign होता है, इसलिए Time2 Object का Original मान 12:33 Return होता है जबकि Time1 का मान अब 12:34 हो जाता है। (Unary Operator Overloading in C++ – TutorialsPoint)