Overloading Assignment Operator

Overloading Assignment Operator: हम Assignment Operator को भी उसी तरह से Overload कर सकते हैं जिस तरह से अन्‍य Operators को करते हैं। लेकिन Assignment Operators का Role Programming में अन्‍य सभी Operators की तुलना में अधिक रहता है। Assignment Operator व Copy Constructor दोनो ही समान तरीके से काम करते हैं। ये दोनों  ही एक Object के Data को दूसरे Object में Copy करते हैं।  जब हम एक Assignment Operator को Overload करते हैं तब हमें एक Object के Data को Member Wise दूसरे Object में Copy करने के अलावा भी बहुत कुछ करना पडता है। = Operator को Overload करने का एक सामान्‍य Syntax निम्नानुसार है:

void operator=(const omega& right)   // overloaded Assignment
{
   // Copy Data if appropriate
}

इस तरीके में ये Function स्वयं की class का ही एक Argument लेता है जिसका return Type void है। यदि हम return Type void रखते हैं तो हम एक श्रृंखला के रूप में ( a = b = c ) = का प्रयोग नहीं कर सकते हैं।  इस syntax में दिया गया “comment Data if appropriate” का मतलब है कि Overloaded Assignment Operator (OAO) ही हर Data Member के एक Object से दूसरे Object में Copy के लिए जिम्मेदार है।

जब हमें एक Object के सभी Data Members को ज्यों का त्यों दूसरे Object में Copy करना होता है, तब Assignment Operator को Overload करने की जरूरत नही होती है। Assignment Operator ये काम बिना Overload हुए ही कर देता है। इसे तभी Overload करना चाहिए जब हमें अलग प्रकार से इसे Use करना हो। ध्‍यान दें कि OAO Copy Constructor के कितना समान तरीके से काम करता है।

omega(const omega& om)   // Copy Constructor
{
   // Copy Data if appropriate
}

Copy Constructor व Assignment Operator में मुख्‍य अंतर यही है कि Copy Constructor Data Copy करने से पहले एक नया Object बनाता है जबकि Assignment Operator पहले से बने Object में किसी अन्‍य Object के Data को Copy कर देता है। ध्‍यान रखें कि Equal Sign का मतलब Definition व Assignment दोनों में भिन्न होता है:

omega beta = alpha;   	// construction and initialization uses Copy Constructor
beta = alpha;         	// Assignment uses Assignment operator

पहले Statement में Assignment Operator use नहीं हुआ है। केवल दूसरे Statement में ही Assignment Operator Use हुआ है। Overloaded Assignment Operator का निम्न उदाहरण देखे:

Program
	// demonstrates overloaded Assignment operator
	// using Objects that number themselves
	#include <iostream.h>
	#include <string.h>         	// for strncpy()

	class omega
	{
		private:
			enum { size=20 };
			char name[size];
			static int total;
			const int number;

		public:                  	// one-arg Constructor
			omega(char str[]) : number(++total)  	// number the Object
			{
				strncpy(name, str, size);        	// give it a name
				cout << "\n1-arg Constructor has "<<"Created"<<name << "-" << number;
			}
			
			// overloaded Assignment operator
			void operator=(const omega& right)
			{
				cout<<"\n"
					<<right.name
					<<"-"<<right.number
					<<"assigned to"
					<<name<<"-"<<number;
				strncpy(name, right.name, size);  	// Copy the name
				cout << ", making " << name << "-" << number;
			}
	};

	int omega::total = 0;        	// (no Objects when program starts)
	void main()
	{
		omega om1("Harriet");     // uses one-arg Constructor
		omega om2("Bernard");
		om2 = om1;                // Assignment
	}

Copy Constructor की तरह ही जब कोई Object Create किया जाता है तब Assignment Operator को Overload करना जरूरी होता है।

A Simple Assignment Operator Example

जब हमें कुछ खास प्रकार के काम करने होते हैं जैसे कि जब कोई Object Creation के समय Object को Memory Allocate करना या जब Object Pointers को Use करता है या जब Object कुछ Unusual जैसे कि Objects की Counting या Numbering करते हैं, तब = Operator को Overload करना जरूरी होता है। चलिए, एक Program द्वारा इसे समझने की कोशिश करते हैं।

Program
// demonstrates overloaded Assignment operator
// using Objects that number themselves
#include <iostream.h>
#include <string.h>         	// for strncpy()

class omega
{
	private:
		enum { size=20 };
		char name[size];
		static int total;
		const int number;
 
	public:                  	// one-arg Constructor
		omega(char str[]) : number(++total)  	// number the Object
		{
			strncpy(name, str, size);        // give it a name
			cout << "\n1-arg Constructor has "
			<< "Created " << name << "-" << number;
		}

		// overloaded Assignment operator
		void operator=(const omega& right)
		{
			cout << "\n" << right.name << "-" << right.number
			<< " assigned to " << name << "-" << number;
			strncpy(name, right.name, size);  	// Copy the name
			cout << ", making " << name << "-" << number;
		}
};
int omega::total = 0;        	// (no Objects when program starts)
void main()
{
	omega om1("Harriet");     // uses one-arg Constructor
	omega om2("Bernard");
	om2 = om1;                // Assignment
}

इस Program में omega class में तीन Data Item हैं। OAO इनमें से केवल एक name को strncpy() Library Function को Use करके Copy करता है। दूसरा Data Item total Static है। Static Data को कभी भी OAO या Copy Constructor द्वारा Copy नहीं किया जा सकता है, क्योंकि ये पूरी Class पर Apply होता है ना कि किसी अमुक Object पर।

हमने number Data Item को Copy नहीं किया है, क्योंकि Object Creation के समय ही हर Object को एक Permanent Serial Number दे दिया जाता है। ऐसा हमने number को const Keyword द्वारा Constant करके किया है।

हमने number Data Item को Copy नहीं किया है, क्योंकि Object का Serial Number Object Creation के समय ही Object में Initialize हो जाता है साथ ही हमने इसे const रखा है, जिससे Compiler इसे Change नहीं करने देता है।

जब एक Object में किसी Data Item को const रखा जाता है, तब हमें Assignment Operator को व Copy Constructor को Overload करना जरूरी होता है क्योंकि Compiler Default Memberwise Copy को Use नहीं करता है, जो कि Unchangeable const को Change करने में Involve है। main() program में Program दो Objects Create करता है और OAO एक Massage के रूप में ये बताता है कि वह क्या कर रहा है। इस Program का Output निम्नानुसार है:

1-arg Constructor has Created Harriet-1
1-arg Constructor has Created Bernard-2
Harriet-1 is assigned to Bernard-2, making Harriet-2

Om2 नाम का Object, जो कि Bernard-2 के तौर पर शुरू होता है, Harriet-2 में Convert हो जाता है। इसका नाम बदल जाता है लेकिन इसका number नहीं बदलता है। ये बिल्कुल उसी तरह से होता है जैसे कोई व्‍यक्ति अपना नाम बदल सकता है। लेकिन उसका SSN (Social Security Number) Change नहीं होता है। हम Default Member Wise Assignment Operator को chain के रूप में भी Use कर सकते हैं। जैसे

var3 = var2 = var1;

इस प्रकार से Assignment हो सके इसके लिए, Assignment Operation का Result इसके Left side में Available होना चाहिए। Assignment Operator के लिये ये जरूरी हो जाता है कि वह Operand के मान को इसके Left में Return करे। OAO की इस स्थिती में, ये उसका Object होता है जिसके लिए इसे Call किया गया है। इस प्रक्रिया को निम्नानुसार बताया गया है:

omega operator=(const omega& right)    // overloaded Assignment op
{
   // Copy Data if appropriate
   return omega(name);                  // returns by value; uses
}                                    	// 1-arg Constructor

यहां return Statement One-Argument Constructor को Use करता है ताकि उस Object की एक नई Temporary Copy बन सके जिसके लिए OAO को Call किया गया है, जो कि = Sign के Left का Object है। इसे निम्न Program में समझा जा सकता है:

// Program
	// overloaded Assignment operator with self-numbering Objects returns a value
	#include <iostream.h>
	#include <string.h>           	// for strncpy()

	class omega
	{
	private:
		enum { size=20 };
		char name[size];
		static int total;
		const int number;

	public:
					// one-arg Constructor
		omega(char str[]) : number(++total)
		{
			strncpy(name, str, size);
			cout << "\n1-arg Constructor has "
			<< "Created " << name << "-" << number;
		}
		~omega()
		{
			cout << "\nDestructor has "
			<< "destroyed " << name << "-" << number;
		}
					// overloaded Assignment operator
		omega operator=(const omega& right)
		{
			cout << "\n\n" << right.name << "-" << right.number
			<< " assigned to " << name << "-" << number;
			strncpy(name, right.name, size);
			cout << ", making " << name << "-" << number;
			return omega(name);
		}
	};
	int omega::total = 0;          	// no Objects when program starts

	void main()
	{
		omega om1("Harriet");       // uses one-arg Constructor
		omega om2("Bernard");
		omega om3("Damien");
		om3 = om2 = om1;            // chained Assignment
	}

// Output:
	1-arg Constructor has Created Harriet-1
	1-arg Constructor has Created Bernard-2
	1-arg Constructor has Created Damien-3
                                          
	Harriet-1 assigned to Bernard-2, making Harriet-2
	1-arg Constructor has Created Harriet-4

	Harriet-4 assigned to Damien-3, making Harriet-3
	1-arg Constructor has Created Harriet-5

	Destructor has destroyed Harriet-5
	Destructor has destroyed Harriet-4

	Destructor has destroyed Harriet-3
	Destructor has destroyed Harriet-2
	Destructor has destroyed Harriet-1

इस Output के पहले तीन Sentences main() Function में 1-Argument Constructor को Invoke करते हैं। उसके बाद निम्नानुसार Assignment Chain Execute होता है:

om3 = om2 = om1;

इस Statement का हर Assignment Operator एक name Variable को Assign करता है और 1-Argument Constructor को Execute करके एक Temporary Variable Create करता है जिसे Assigned किया जाता है। ये Temporary Objects Harriet-4 व Harriet-5 हैं। ये दोनों Objects Statement के अन्त में Destroy हो जाते हैं।

जब Program का अन्त होता है तब तीन Original Objects उनके नाम (Harriet-1, Harriet-2 व Harriet-3) के साथ Destroy हो जाते हैं। (Overloading Assignment Operator – WikiBooks)