Class to Class Type Conversion in C++

Class to Class Type Conversion in C++: हम एक Class के Object को दूसरे class के Object में भी Convert कर सकते हैं, लेकिन हमें इस बात का ध्‍यान रखना चाहिए कि किया जाने वाला Conversion किसी काम का है या नहीं। जैसे TTime class के Object को Emp class के Object में Convert करने का कोई मतलब नहीं है।

हम बडे Conversion करने से पहले एक छोटा सा Conversion Example देखते हैं। इसमें दो Class alpha व beta है जिनके Objects को alpha से beta व beta से alpha में Convert कर रहे हैं।

Program
	class alpha
	{
	private:
		int ia;

	public:
		alpha(int i)             // Converts int to alpha
		{ ia = i; }

	int get_ia()             	// "peek" Function
	{ return ia; }
	};
	class beta
	{
		private:
			int ib;

		public:
			beta(alpha a)            // Converts alpha to beta
			{ ib = a.get_ia(); }  	// uses alpha get_ia()

			operator alpha()         // Converts beta to alpha
			{ return alpha(ib); } 	// uses alpha 1-arg constr
	};
	void main()
	{
		alpha a(11);   	// alpha 1-arg Constructor; int to alpha
		beta b(a);     	// beta 1-arg Constructor; alpha to beta
		a = b;         	// beta operator alpha(); beta to alpha
	}

इन दोनों ही class में int प्रकार का एक Data Item है। class alpha में एक one-Argument Constructor है जो int मान को alpha Type में Convert करता है या alpha को एक int मान से Initialize करता है। Class alpha में एक peek Function भी है जो Read Only रूप में Program के अन्‍य हिस्से में अपने Data Item को Access करने की सुविधा प्रदान करता है। इस Access की जरूरत beta Class में One-Argument Constructor को होती है।

Class beta में one-Argument Constructor एक alpha Object को beta Object में Convert करता है। ये Conversion करने के लिए alpha Class के get_ia() Peek Function को Call करके alpha के Data को प्राप्त किया जाता है और इसके स्वयं के Object को वह Data Assign किया जाता है। beta Class का दूसरा Member Function operator alpha() है जो beta को alpha Class में Call किया करता है और alpha Class से Return होता है। Constructors व Class Operators दोनों Conversion Functions beta Class में हैं। फिर भी हम इन्ही दोनों Functions को Class alpha में Define करके भी Conversion को Handle कर सकते हैं।

main() Function में Program beta में alpha को Initialize करके Conversion को Text करता है। इसका कोई Output नहीं है। ध्‍यान दें कि Class alpha को Class beta से पहले लिखना जरूरी है क्योंकि Class beta में Class alpha के Member Functions को Use किया जा रहा है।

Class Conversion को समझने के लिए हम एक और अधिक Practical उदाहरण देखते हैं। इसमें एक नई Class FracFeet को Define किया गया है। ये Class Distance को feet व foot के Fraction को Store करता है। इसमें तीन Data Items है जो feet व उसके दसमलव वाले हिस्से को Represent करते हैं। ये निम्नानुसार मानों को Display करता है:

6-1/2 ft

जिसका मतलब साढे छ: फुट है। इसका User से Interaction कुछ निम्नानुसार होता है:

Enter feet: 7

Enter fraction (format 2/3): 3/4

इस Program में दो Classes English व FracFeet हैं और दोनों ही Distance को English System में Store करते हैं। इसलिए इनके बीच Conversion Logical है।

Program
	//The FracFeet Class 
	// Converts between English and FracFeet
	#include <iostream.h>
	class English                     	// feet-and-inches class
	{
		private:
			int feet;
			float inches;

		public:                        	// no-Argument Constructor
			English() : feet(0), inches(0.0) {  }
            
					// 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 << '\"'; 
			}

			// these Functions needed for Conversions
			int getfeet()               	// return feet
			{ 
				return feet; 
			}
      
			float getinches()           	// return inches
			{
				return inches; 
			}
	};  // end English class

	class FracFeet                    	// fractional feet class
	{
		private:
			int wfeet;                  	// whole feet
			int numer;                  	// numerator
			int denom;                  	// denominator

		public:                        	// no-Argument Constructor
			FracFeet() : wfeet(0), numer(0), denom(1) {  }

			FracFeet(English);          	// one-Argument Constructor
			// (declaration)

		void get()                  	// user input (never use 0
		{                        	// in denominator)
			char dummy;
			cout << "   Enter feet: ";
			cin >> wfeet;
			cout << "   Enter fraction (format 2/3): ";
			cin >> numer >> dummy >> denom;
		}

		void display()              	// display
		{
			cout << wfeet;
			if(numer != 0)           	// if numerator 0, no fraction
			cout << '-' << numer << '/' << denom;
			cout << " ft";
		}

		operator English()          	// Convert FracFeet to English
		{                        	// inches = 12 * n / d
			float temp_inches = 12.0 * float(numer) / float(denom);
			return English( wfeet,  temp_inches);
		}
	};  // end class FracFeet

	FracFeet::FracFeet(English e)     	// one-Argument Constructor
	{                              	// Convert English to FracFeet
		wfeet = e.getfeet();           	// feet are the same
		int i = int( e.getinches() );  	// Convert inches to integer
					// find fraction
		if(i==6) { numer=1;   denom=2; }   	// 1/2
		else if(i==2 || i==10) { numer=i/2; denom=6; }   	// 1/6, 5/6
		else if(i==3 || i== 9) { numer=i/3; denom=4; }   	// 1/4, 3/4
		else if(i==4 || i== 8) { numer=i/4; denom=3; }   	// 1/3, 2/3
		else { numer=i;   denom=12;}   	// i/12
	}

	void main()
	{
		FracFeet ff;
		English eng;

		cout << "\nFracFeet value\n";
		ff.get();                      	// get FracFeet from user
		cout << "FracFeet = ";
		ff.display();                  	// display FracFeet

		eng = ff;                      	// Convert FracFeet to English
		cout << "\nEnglish = ";
		eng.display();                 	// display equivalent English

		cout << "\n\nEnglish value\n";
		eng.get();                     	// get English from user

		cout << "English = ";
		eng.display();                 	// display English

		ff = eng;                      	// set English to FracFeet
		cout << "\nFracFeet = ";
		ff.display();                  	// display equivalent FracFeet
	}

आप देख सकते हैं कि इस Program में दो class हैं। main() Function में Program दोनों तरह के Conversions करता है। पहला] एक FracFeet Object User से Data लेता है और उसे Display करता है। फिर ये Program एक English Object को FracFeet के बराबर करता है और इसे Display करता है। ये बता रहा है कि FracFeet से English Object में Conversion हो रहा है। दूसरा, एक English Object User से Data लेता है और इसे Display करता है। Program FracFeet को English Object के बराबर करता है और फिर English Object को Display करता है। इस Program का Output निम्नानुसार आता है:

FracFeet value
Enter feet: 7
Enter fraction (format 2/3): 3/4
FracFeet = 7-3/4 ft
English = 7′-9″

English value
Enter feet: 3
Enter inches: 8
English = 3′-8″
FracFeet = 3-2/3 ft

ध्‍यान दें कि FracFeet class की Specifications English class की Specifications को Follow करता है। ये क्रम जरूरी है क्योंकि Conversion Function FracFeet में है। FracFeet के ये Conversion Function English class के Member Function को Access करते हैं इसलिए English class को पहले बनाना जरूरी है। FracFeet class में English() Operator FracFeet से English में, English class के two-Argument Constructor द्वारा मान प्राप्त करके Conversion करता है।

FracFeet class का one-Argument Constructor English Object को FracFeet class के Object में Convert करता है।  ऐसा करने के लिए इस Constructor को English class के Private Data को Access करना पडता है। ये तब तक सम्भव नहीं है जब तक कि English class में कोई public Member Function ना हो जो कि इस प्रकार के Data Member को access करने की सुविधा प्रदान करे।

get_feet() व get_inches() Member Function ये सुविधा प्रदान करते हैं। FracFeet class में English Object में Argument के रूप में Pass feet व inches के मान को one-Argument Constructor इन Member Functions को Call करता है। English inches को FracFeet class में दसमलव वाले भाग को numerator व denominator में Convert करना जरूरी होता है। Constructor ये काम इस पर निर्भर करते हुए कि numerator व denominator के लिए कितने Inches हैं, else…if Ladder द्वारा करता है।

इस Program के FracFeet Class का English() Operator FracFeet को 2-Argument Constructor द्वारा मान Supply करके English मान में Convert करता है। feet का मान दोनों Classes में समान है जबकि foot के दसमलव वाले हिस्से को Inches में Convert किया गया है। FracFeet Class का 1-Argument Constructor एक English Object को FracFeet Object में Convert करता है। ऐसा करने के लिए इसे English Object के Private Data को Access करना पडता है। ऐसा तब तक सम्भव नहीं है, जब तक कि English Class में एक Public Member Function ना हो जो इस प्रकार के Access की सुविधा प्रदान करे।

get_feet() व get_inches() Member Functions ये काम करते हैं। FracFeet Class का 1-Argument Constructor इन Functions को Call करके feet व inches के मानों को प्राप्त करने के लिए English Object में Argument के रूप में Pass करता है।  English inches को FracFeet Class में Numerator व Denominator में Convert करना होता है। ये काम Numerator व Denominator से मानों को Select करके else . . . if Ladder करता है। (Class to Class Type Conversion in C++ – WikiBooks)