Conversion Constructor

Conversion Constructor : इस प्रकार के Constructors का OOPS में बहुत महत्व है। इस प्रकार के Constructors किसी एक Class के Object को किसी दूसरी Class के Objects में Convert करने के काम में लाए जाते हैं। यानी ये Constructors एक Data Type के Objects को दूसरे Data Type के Object में बदलने का काम करते हैं। इस प्रकार के Constructor को Conversion Function भी कहा जाता है। इसे समझने के लिए निम्न उदाहरण देखते हैं:

	class typeA
	{
	   typeA(int i)  // 1-Argument Constructor
	   {
		 // Convert the int value to a typeA value
	   }
	};

इस Constructor को int प्रकार के Variable को Class typeA के Object में Convert करने के लिए Use किया जा सकता है। ध्‍यान दें कि किसी Data Type का Variable कहा जाए या किसी Class का Object कहा जाए, दोनों का मतलब समान ही है। हम इस तरह के Conversion Function को दो तरह से लिख सकते हैं। पहला तरीका निम्नानुसार है:

	void main()
	{
	   int intv = 27;     // an integer with a value
	   typeA ta(intv);    // initialize typeA Object with int
	}

इसमें typeA Object को int प्रकार के एक मान को Object के नाम के साथ कोष्‍ठक में लिख कर Initialize किया गया है। typeA ta(intv); Statement के स्थान पर हम = चिन्ह का भी प्रयोग कर सकते हैं। यानी

typeA ta = intv;    // exactly the same as typeA ta(intv);

ये दोनो ही Statement एक समान हैं। हालांकि ये एक Assignment Statement के समान लगता है, लेकिन यहां = चिन्ह किसी प्रकार का Assignment नहीं कर रहा है। ये ta को intv की Value Initialize कर रहा है। इस प्र्रक्रिया को One-Argument Constructor Call करना भी कहते हैं। ta = tb; Statement किसी Constructor को Call नहीं करता है। Initialization व Assignment दोनों समान नहीं होते हैं। ये एक बहुत ही खास बात है जिसे आगे जरूरत पडने पर अधिक विस्तार से समझाया जाएगा।

Conversion Constructor – Strings to xStrings

Data Conversion का एक और अच्छा सा उदाहरण देखते हैं। हम एक Program बना रहे हैं और उसी Program में थोडा सा Modification करके उसे Conversion में Convert कर रहे हैं।

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

const int MAX = 80;             	// maximum length of xStrings

class xString
{
   private:
	  char str[MAX];            	// ordinary C string

   public:
	  void init( char s[] )     	// initialize with string
	  {
		 strcpy(str, s);
	  }

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

	  void display()            	// display string
	  {
		 cout << str;
	  }

	  void append(xString xs)   	// append Argument string
	  {
		 if(strlen(str) + strlen(xs.str) < MAX-1)
			strcat(str, xs.str);
		 else
			cout << “\nError: xString too long” << endl;
	  }
};

void main()
{
   xString s1, s2, s3;         	// make xString Objects

   s1.init(“Greetings, ”);     	// initialize s1

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

   s1.append(s2);              	// append s2 to s1
   s3 = s1;                    	// set s3 to s1
   s3.display();               	// display s3
}

इस Program में main() Function में तीन xString Object Create किए गए हैं। s1 में init() Member Function का प्रयोग करके एक String Initialize किया गया है। input() Member Function का प्रयोग करके Object s2 के लिए User से एक String Accept किया गया है।

append() Member Function s1 व s2 की Strings को जोडने का काम करता है। String को जोडने के बाद Assignment Operator का प्रयोग करके Object s1 की String को s3 में Assign किया गया है और अंत में Object s3 को Print किया गया है।

इसी Program में थोडा सा परिवर्तन करके इसे One Argument Constructor में Convert किया गया है। ये One-Argument Constructor एक साधारण null-terminated String को xString Object में Convert करने के लिए Use किया गया है। Modified Program निम्नानुसार है:

// Program
#include <iostream.h>
#include <string.h>             	// for strlen(), strcpy(), etc.
const int MAX = 80;             	// maximum length of xStrings
class xString
{
	private:
		char str[MAX];            // ordinary C string

	public:
		xString()                 // no-arg Constructor
		{
			strcpy(str, "");  // make null string
		}

		xString( char s[])        // 1-arg Constructor
		{
			strcpy(str, s);   // initialize with string
		}

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

		void display()            // display string
		{
			cout << str;
		}

		void append(xString xs)   // append Argument string
		{
			if(strlen(str) + strlen(xs.str) < MAX-1)
			strcat(str, xs.str);
			else
			cout << "\nError: xString too long" << endl;
		}
};

void main()
{
	xString s2, s3;              // make xString Objects
	xString s1("Greetings, ");   // make and initialize s1
	cout << "Enter your name: ";
	s2.input();                  // get s2 from user
	s1.append(s2);               // append s2 to s1
	s3 = s1;                     // set s3 to s1
	s3.display();                // display s3
}

इस प्रोग्राम में एक xString Object को एक String प्रदान करने के लिए init() Member Function के स्थान पर One-Argument Constructor का प्रयोग किया गया है। xString s1(“Greetings, “); Statement द्वारा एक सामान्‍य String “Greetings”, एक xString Object s1 में Convert हो गया है।

जैसाकि हमने पहले भी कहा कि 1-Argument Constructor Conversion का काम करता है। यही काम यहां पर भी हो रहा है, यानी एक सामान्‍य String Data एक xString Object में Convert हो रहा है।

इस Program में यदि हम s2 व s3 Objects को Print करें, तो Output में कुछ भी Print नहीं होता है। क्योंकि जब ये Objects Create होते हैं, तब No-Argument Constructor Execute होता है और Array में Null Initialize कर देता है।

लेकिन जब हम s1 को Define करते हैं, तो उसके Parenthesis में एक String भी Pass करते हैं। इससे 1-Argument Constructor Execute होता है और Array में String को Copy कर देता है।

इसी Program में हम देख सकते हैं, कि एक ही नाम व विभिन्न Arguments के दो Constructors को Use किया है। ये Constructor Overloading का एक अच्छा उदाहरण है। हम जानते हैं कि String भी एक प्रकार का One-Dimensional Array है, इसलिए हम इस Program में निम्नानुसार Initialization नहीं कर सकते हैं:

xString( char s[]) : str(s[]){} // can’t do this — s is an array

हम किसी Array को इस तरह से इसलिए Initialize नहीं कर सकते हैं, क्योंकि एक Array के Declaration का मतलब होता है कि हम एक ही Statement द्वारा कई Variables को एक साथ Declare कर रहे हैं।

जबकि इस प्रकार के Initialization Statement द्वारा हम केवल एक ही Variable को Initialize कर सकते हैं। इसीलिए हमें किसी Array को Initialize करने के लिए निम्न Format को Use करके Array के सभी Elements को Initialize करना होता है:

    xString( char s[])       // 1-arg Constructor
    {
       strcpy(str, s);       // initialize with string
    }

Conversion Constructor – Meters to English Distances

One-Argument Constructor का एक और उदाहरण देखते हैं। इस उदाहरण में हमने एक Class बनाई है जो distance को feet व inch में लेता है। हम इस class को English नाम से Use करेंगे क्योंकि feet व inch English Measurement System में Use होता है। इस प्रणाली में एक foot को 12 inch मे विभाजित किया जाता है। feet को Single Quote व Inch को Double Quote से दर्शाया जाता है। जैसे 6’ – 2”। एक Meter में 3.280833 Feets होते हैं।

इस प्रोग्राम में एक One-Argument Constructor Meters को एक English Object (Feet and Inch) में Convert करने का काम करता है, जो कि Feet व Inches को अलग-अलग Store करता है। हम यहां एक two-Argument Constructor को भी Use करेंगे जो कि एक Object में int value को feet में व float values को inches में Convert करेगा। इन Constructors के साथ हमें एक अन्‍य no-Argument Constructor की भी जरूरत होगी जो कि feet व inches को 0 Initialize करेगा। प्रोग्राम निम्नानुसार है:

// Program
#include <iostream.h>
class English                            	// English distances
{
	private:
	int feet;
	float inches;

	public:                               	// no-Argument Constructor
	English() : feet(0), inches(0.0) {}
	English(float meters)              	// 1-Argument Constructor
	{
		const float MTF = 3.280833;     // meters to feet
		float fltfeet = MTF * meters;   // get decimal feet
		feet = int(fltfeet);            // integer part is feet
		inches = 12 * (fltfeet-feet);   // remainder is inches
	}

	English(int f, float i):feet(f), inches(i) {}  // 2-Argument Constructor
	void display()                     	// display
	{
		cout << feet << "\'-" << inches << '\"';
	}
};

void main()
{
	English E1(5, 2.5);        // Call 2-arg Constructor
	cout << "\nE1 = ";
	E1.display();
	English E2(2.0);           // Call 1-arg Constructor
	English E3;                // Call no-arg Constructor
	E3 = E2;
	cout << "\nE3 = ";
	E3.display();
}

इस Program में English Object E1 को feet व inches की Value Initialize की गई है। E2 Object को meters में मान Initialize किया गया है और e3 को no-Argument Constructor की तरह Use करके e2 का मान Initialize किया गया है। इस तरह Program का Output निम्नानुसार प्राप्त होता है:

E1 = 5′-2.5″
E3 = 6′-6.73999″

One-Argument Constructor के बारे में एक बात हमेंशा ध्‍यान रखें कि हम इनका प्रयोग केवल तभी कर सकते हैं, जब Object Basic Variables को Represent करता है। हम इनका प्रयोग Real World Objects के साथ नहीं कर सकते हैं। ऐसा इसलिए क्योंकि Real World Object की class में कभी भी एक Data Member नहीं होता है। (Conversion Constructor – StackOverflow)