Type Conversion – Basic to Class | Class to Basic

Type Conversion: हम समझ सकते हैं कि “C++” में Conversion कितना महत्वपूर्ण Operation है। जब हम किसी Basic प्रकार के Variable के साथ प्रक्रिया कर रहे होते हैं, तब हमें इस सम्बंध में विशेष ध्‍यान देने की जरूरत नहीं होती है। क्योंकि ये Conversion Basic Data Types के Variables के साथ Automatically होता है। जैसे:

floatVariable = intVariable;

 जहां floatVariable एक Float प्रकार का Variable है जबकि intVariable एक Integer प्रकार का Variable है। यहां int प्रकार के Variable का मान Automatically float प्रकार के Variable में float प्रकार से Store हो जाता है। जैसे यदि intVariable का मान 12 हो तो floatVariable में ये मान 12.0 के रूप में Automatically Store हो जाता है। इस प्रकार के Conversion के लिए जिस Basic Routine की जरूरत होती है, वह Routine “C++” में Built – In होता है। लेकिन जब Classes के या User Defined Data Type के सम्बंध में बात करते हैं, तब ये स्थिति नहीं होती है। यदि हम एक Class प्रकार के Object के मान को किसी Basic प्रकार के Variable के मान में Convert करना चाहें, एक Class के Object के मान को दूसरी Class के Object के मान में Convert करना चाहें, तो हमें Conversion Function या Routine स्वयं को ही लिखना पडता है। इस विषय में Compiler हमारी कोई मदद नहीं कर सकता है। Conversion Routines को हम मुख्‍यतया तीन भागों में निम्नानुसार विभाजित कर सकते हैं:

• From Basic Types to Objects
• From Objects to Basic Types
• From Objects to Objects of another class

 हमने Conversion के अभी तक कई उदाहरण पहले ही देख लिए हैं जिनमें Basic प्रकार के Data को किसी Class प्रकार के Data में Convert किया है। इस Conversion को मुख्‍यतया एक 1-Augment Constructor द्वारा Handle किया जाता है जहां Argument एक Basic प्रकार का मान होता है।  हमने पिछले अध्‍याय में देखा है कि किस प्रकार से एक साधारण String को xString प्रकार के Object में Convert किया जा सकता है और किस प्रकार से एक float प्रकार के Meters को Represent करने वाले मान को एक English प्रकार के मान में Convert किया जा सकता है।

Type Conversion :  Casting for Basic Types

इससे पहले कि हम ये देखें कि किस प्रकार से एक Object को Basic Type में Convert करते हैं, हम ये देखते हैं कि किस प्रकार से एक Basic प्रकार का Data दूसरे Basic प्रकार के Data में Convert होता है। दोनों प्रकार के Conversions का तरीका एक समान ही है। हम जानते हैं कि Basic प्रकार के Conversions Automatically हो जाते हैं। इनके लिये Programmer को कोई खास प्रक्रिया नहीं अपनानी पडती है। फिर भी, कई बार Programmer को Compiler को बताना पडता है कि किस प्रकार से Conversion किया जाना है।  उदाहरण के लिए एक Function देखते हैं, जिसमें किसी Floating Point मान के Real Part व Imaginary Part को अलग करना है। जैसे कि हम 123.45 को दो भागों में बांटना चाहें, तो हमें एक मान 123.0 व दूसरा मान 0.45 प्राप्त होना चाहिए। ये दोनो ही Number float प्रकार के हैं। आइये देखते हैं कि इस काम के लिए Member Function किस प्रकार से लिखे जा सकते हैं:

	float parts(const float& orig, float& fracpart)
	{
	   float wholepart = int(orig);   	// find whole part
	   fracpart = orig - wholepart;   	// find fractional part
	   return wholepart;              	// return whole part
	}

Function में प्रथम Argument Original Number का है। दूसरा Argument मान के दसमलव वाले भाग को Store करने के लिए है। ये Function Real Number मान को Return करता है। इस Function को निम्नानुसार Call किया जा सकता है:

wpart = parts(original_number, fpart);     // Call to Function

 इस Function के Operation का मुख्‍य आधार निम्न Statement है।

float wholepart = int(orig);

जो कि Floating Point Number के Fractional Part को छोड दिया जाता है। पूर्णांक वाला भाग wpart Variable को प्राप्त हो जाता है। ऐसा इसलिए हो जाता है क्योंकि int(orig) Statement Number के साथ कोई प्रक्रिया नहीं कर पाता है। क्योंकि ये केवल पूर्णांक मान पर ही प्रक्रिया करता है।  यहां Casting करने के लिए int को इस प्रकार से Use किया गया है जैसे कि ये कोई Function हो। ये int Operator को Call करता है। Variable orig जिसकी हम यहां Casting कर रहे हैं, इस int() Function के Argument के रूप में Use हो रहा है और Return मान उस Variable के Data Type के अनुसार है जिसे प्राप्त मान Accept करने के लिये Use किया जा रहा है। यहां wholepart float प्रकार का है, इसलिए Return मान भी float प्रकार का Return होता है। Casting का यही तरीका किसी भी अन्‍य प्रकार के Basic Type को किसी अन्‍य Basic Type में Convert करने का काम करता है।

Type Casting करना थोडा Critical काम है। क्योंकि Type Casting करने से हमारे Data का Loss हो सकता है। जैसे यदि long प्रकार के मान 12.32423423 को int प्रकार के मान में Convert किया जाए तो int प्रकार के मान में केवल 12 ही Store होगा, दसमलव के बाद का सारा मान Damage हो जाएगा। Type Casting का एक अन्‍य तरीका भी है। इस तरीके को “Functional” Syntax कहा जाता है, क्योंकि ये एक Function की तरह दिखाई देता है। जैसे

var2 = long(var1);  // “Functional” syntax

 यहां var1 long प्रकार में Convert हो जाता है। हम निम्नानुसार एक अन्‍य तरीका भी Use कर सकते हैं, लेकिन ये तरीका “C” में प्रयोग किया जाता है। फिर भी कई बार आवश्‍यकतानुसार इसे “C++” में भी Use किया जा सकता है:

        var2 = (long)var1;  // alternative syntax (not recommended)

Conversion from English to float

हम Cast Syntax का प्रयोग किसी class Object को Basic Data Type में Convert करने के लिये भी कर सकते हैं। फर्क सिर्फ ये है कि class Creator को इस काम के लिए अलग से Routine (Functions) लिखने पडते हैं। ये काम भी operator keyword का प्रयोग करके किया जा सकता है जिसका प्रयोग हमने Operator Overloading में किया है।  उदाहरण के लिए हम यहां बता रहे हैं कि किस प्रकार से एक class Object को Basic Data Type long में Convert किया जा सकता है:

	operator long()
	{
	   // Conversion performed here
	   return longvar;
	}

हालांकि ये Function long मान Return करता है, जबकि हमने कोई Return Type Specify नहीं किया है। ये Return मान Function को Use किये जाने के तरीके पर निर्भर करता है। जैसाकि हम देख चुके हैं कि long() Operator Basic Data Type पर काम करता है, लेकिन आप इसे Overload करके अपनी स्वयं की class के साथ भी Use कर सकते हैं।  इसे समझाने के लिए हम यहां एक English प्रकार के Object (feet and inches) को एक float प्रकार के Variable या Object] जो कि meters को Represent कर रहा है, में Convert कर रहे हैं। ऐसा हम float() Operator को Overload करते हुए कर रहे हैं। Program निम्नानुसार है:

// Program
	#include <iostream.h>

	class English                         	 // English distances
	{
	   private:
		  int feet;
		  float inches;
		  Static const float MTF;      	// meters to feet, declaration

	   public:                            	 // no-Argument Constructor
		  English() : feet(0), inches(0.0) {  }

		  English(float meters)          	// 1-Argument Constructor
		  {
			 float fltfeet = MTF * meters;   // get decimal feet
			 feet = int(fltfeet);          	// integer part is feet
			 inches = 12 * (fltfeet-feet); 	// remainder is inches
		  }

		 // 2-Argument Constructor
		  English(int f, float i) : feet(f), inches(i) {  }

		  void get()                     	// user input
		  {
			 cout << "   Enter feet: ";   cin >> feet;
			 cout << "   Enter inches: "; cin >> inches;
		  }

		  void display()                 	// display
		  {
			 cout << feet << "\'-" << inches << '\"';
		  }

		  operator float()               	// Convert English to float
		  {
			 float fracfeet = inches/12;  	// inches to feet
			 fracfeet += float(feet);     	// add the feet
			 return fracfeet/MTF;          	/ Convert to meters
		  }                             	// and return
	};  // end English class

	const float English::MTF = 3.280833;   	// meters to feet, definition
	void main()
	{
	   English engman(1.9);               	// meters to English
	   cout << "\nengman = ";
	   engman.display();                  	// display English

	   float metman;
	   metman = float(engman);             	// English to meters
	   cout << "\nmetman = " << metman;    	// display meters
	}

इस English class में एक one-Argument Constructor है जो कि float प्रकार के मान को English प्रकार में Convert करता है और एक float()Function है, जो कि English प्रकार के Object को float प्रकार में Convert कर रहा है। main() Program में engman Object द्वारा एक float प्रकार का मान 1.9 meters English Object में Convert होता है। ये English मान 6’-2.803” display होकर फिर से float प्रकार में निम्न Statement द्वारा Convert हो जाता है:

metman = float(engman);  // English->float Conversion

 फिर Program meters में मान Display करता है। इस Program का Output निम्नानुसार प्राप्त होता है:

engman = 6′-2.803″

metman = 1.9

Conversion Function Invoked Automatically

एक अन्‍य Syntax भी float() Member Function को Call कर सकता है। जैसे यदि हम निम्नानुसार एक Syntax लिखते हैं:

metman = engman;  // also causes the English->float Conversion

 तो Compiler ये समझेगा कि वह एक English Value को float Value में Convert नहीं कर सकता है, जब तक कि पहले इसे Convert ना किया जाए। इसलिए Compiler ऐसा करने का कोई रास्ता खोजेगा।  इसके लिए इसे float() Member Function प्राप्त होगा और ये Conversion कर लेगा हालांकि हमने इस Member Function को Call नहीं किया है। float() Function Initialization के समय भी स्वयं ही Call हो जाएगा:

float metman(engman);

 इस Statement में metman को engman का मान Initialize किया जा रहा है। लेकिन चूंकि, मान English प्रकार का है इसलिए Compiler float() Function को स्वयं ही Call कर लेगा।

Casting for Clarity

हमने इस प्रोग्राम में दो जगह Cast syntax को Use किया है जबकि वहां इनकी कोई जरूरत नहंी थी। पहली बार One-Argument Constructor में हमने feet = int(fltfeet); लिखा है। यहां Conversion स्वयं ही हो जाता है। हमें int() की जरूरत ही नहीं है क्योंकि feet int प्रकार का ही Variable है। दूसरी बार float() Function में Casting की है। यानी:

fracfeet += float(feet);

 यहां भी int से float प्रकार का Conversion स्वयं ही हो जाता है। एक बात हमेंशा ध्‍यान रखें कि float() जो कि int मान को float मान में Convert करता है और float() Function जो कि English मान को float मान में Convert करता है, दोनों अलग-अलग हैं। पहला वाला float() Built-in है जबकि दूसरा वाला float() Programmer ने अपनी जरूरत के अनुसार बनाया है।

A Static Constant

MTF Member Variable एक Conversion Function है जो कि meters से feet में Conversion का काम करता है। इसे हमने Static बनाया है ताकि इसे हरेक Created Object द्वारा Use किया जा सके तथा इसे हमने const रखा है ताकि इसका मान किसी भी तरह ना बदले।  Conversion from xString to String हम एक और उदाहरण देखते हैं जिसमें Data को Class Type से साधारण Basic में Convert किया गया है। 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[] )		// Convert string to xString
			{
				strcpy(str, s); 
			}
      
			void input()			// get string from user
			{
				cin.get(str, MAX); 
			}
      
			void display()			// display string
			{
				cout << str; 
			}
      
			operator char*()		// Convert xString to string
			{
				return str;
			}
	};

	void main()
	{
		xString s1("Madhav");           	// Constructor Converts
							//    string to xString
		xString s2;					
		cout << "Enter your name: ";
		s2.input();				// get s2 from user
																						// Convert s1, s2 to strings
		if( strcmp(s1, s2)==0 )			// compare them with strcmp()
			cout << "You're Madhav!";
		else
			cout << "You aren't Madhav.";
	}

इस Program में हमने xString Object को साधारण “C” Style String में Convert किया है। ऐसा इसलिए किया गया है क्योंकि “C” में String पर काम करने के लिए कई Built-in Functions हैं जिनका उपयोग हम कर सकते हैं।  main() Function में दो xString Objects की आपस में तुलना करने के लिए हमने strcmp() Library Function को Use किया है। जब Compiler देखता है कि strcmp() Function में जो Object हैं, वे xString प्रकार के हैं, जबकि ये Function String प्रकार के Object का ही Comparison कर सकता है, तो Compiler xString को String में Convert करने के लिए Conversion Function तलाश करता है।

char* () operator को xString class के Objects को String प्रकार में Convert करने के लिए Overload किया गया है। Compiler इसका प्रयोग xString के Object के Conversion के लिए कर लेता है और s1 व s2 को String प्रकार में Convert कर देता है।  आप Member Function operator char*()में * को देख कर परेशान हो सकते हैं कि इसका क्या मतलब है। यहां * का वही काम है जो [] का होता है। ये Character प्रकार का एक Array बताता है। यहां Member Function operator char*() एक xString को string में Convert करता है।

The static_cast Approach  

हमारे पास Type Casting के लिए एक अन्‍य लम्बा Syntax भी है जिसे Type Casting के लिए प्रयोग किया जा सकता है। इसका प्रयोग हम पहले Use किए गए:

feet = int(fltfeet);

 Statement के स्थान पर निम्नानुसार कर सकते हैं:

feet = static_cast<int>(fltfeet);

static_cast एक keyword है जो Casting का काम करता है। return Type को हम <> के बीच लिखते हैं और जिस Variable के मान की Casting करनी है, उसे कोष्‍ठक में लिखते हैं। हम

metman = float(engman);

 Statement द्वारा Casting के स्थान पर निम्नानुसार अन्‍य Statement भी लिख सकते हैं:

metman = static_cast<float>(engman);