Pure Virtual Function in C++

Pure Virtual Function in C++: यदि हम Compiler को ये Instruction दे सकें कि वह किसी Class User को Abstract Class का Object Create ही ना करने दे, तो ये इस समस्या का एक सही समाधान होगा। इस तरीके से हम ज्यादा स्वतंत्रता से Base Classes Design कर सकते हैं, क्योंकि हमें Actual Objects के लिए Plan या Modal बनाने की जरूरत नहीं होगी बल्कि हमें केवल वे Data व Functions ही इस Class के लिए Modal करने पडेंगे, जिनका प्रयोग Derived Classes में किया जाएगा।

हम ये काम Pure Virtual Functions द्वारा कर सकते हैं। यानी Class में Pure Virtual Functions Create करके Compiler को ये बता सकते हैं कि वह Abstract Class के Object Create करने की सुविधा Class User को प्रदान ना करे।

Pure Virtual Function एक ऐसा Function होता है जिसकी Body नहीं होती है और Function Declaration में Notation = 0 Add किया जाता है। चलिए, इसका एक Demo उदाहरण देखते हैं।

// Pure Virtual Function
	#include <iostream.h>
	#include <conio.h>

	class BaseClass                         	// base class
	{
		public:
			virtual void show() = 0;     	// pure virtual function
	};

	class DerivedClass1 : public Base          	// derived class 1
	{
		public:
			void show()
			{ cout << “\nDerivedClass1"; }
	};

	class DerivedClass2 : public Base          	// derived class 2
	{
		public:
			void show()
			{ cout << “\nDerivedClass2"; }
	};
	void main()
	{
		DerivedClass1 dv1;                      // object of derived class 1
		DerivedClass2 dv2;                      // object of derived class 2
		// BaseClass ba;     // Error: cannot create instance of abstract base class
	}

इस उदाहरण में Virtual Function को निम्नानुसार Declare किया गया है:

virtual void show() = 0;          // Pure Virtual Function

इस Statement में मान 0 कुछ भी नहीं करता है। ये मान Function में किसी को भी Assign नहीं होता है। यहां =0 Statement का मतलब Compiler को केवल ये बताना है कि ये एक Pure Virtual Function है, जिसकी कोई Body नहीं है। यदि हम shape Class को Pure Virtual Function के साथ Develop करना चाहें, तो निम्नानुसार इस Class में परिवर्तन करके Class को Abstract Class में परिवर्तित कर सकते हैं:

// Draws shapes made from Xs on character-based display
// uses Pure Virtual draw() Function in BaseClass
#include <iostream.h>
#include <conio.h>

class shape
{
	private:
		int xCo, yCo;             	// coordinates of shape
		int size;                 	// size of shape

	protected:                   		// read-only functions
		int getx() const { return xCo; }
		int gety() const { return yCo; }
		int getz() const { return size; }
		void down() const;        	// declaration

	public:
        	// 3-arg constructor
		shape(int x, int y, int s) : xCo(x), yCo(y), size(s){  }
		virtual void draw() const = 0;  // pure virtual function
};

void shape::down() const        	// move cursor down to top of shape
{
	for(int y=0; y<yCo; y++)
	cout << endl;
}
class square : public shape     	// square shape
{
	public:                      	// 3-arg constructor
		square(int x, int y, int s) : shape(x, y, s){  }
		void draw() const;        	// declaration
};

void square::draw() const       	// draw a square
{
	shape::down();               	// position y at top of shape
	for(int y=0; y<getz(); y++)  	// move y down across shape
	{
		int x;
		for(x=1; x<getx(); x++)   // space over to shape
			cout << ' ';

		for(x=0; x<getz(); x++)   // draw line of Xs
			cout << 'X';
		cout << endl;
	}
}

class cap : public shape                  // cap (pyramid) shape
{
	public:                           // 3-arg constructor
		cap(int x, int y, int s) : shape(x, y, s){  }
		void draw() const;        // declaration
};

void cap::draw() const                    // draw a cap
{
	shape::down();

	for(int y=0; y<getz(); y++)
	{
		int x;

		for(x=0; x < getx()-y+1; x++)
			cout << ' ';

		for(x=0; x<2*y+1; x++)
			cout << 'X';
		cout << endl;
	}
}

class bowl : public shape       	// bowl (inverted pyramid) shape
{
	public:                      	// 3-arg constructor
		bowl(int x, int y, int s) : shape(x, y, s){  }
		void draw() const;      // declaration
};

void bowl::draw() const         	// draw a bowl
{
	shape::down();
 
	for(int y=0; y<getz(); y++)
	{
		int x;
		for(x=0; x < getx()-(getz()-y)+2; x++)
			cout << ' ';
 
		for(x=0; x < 2*(getz()-y)-1; x++)
			cout << 'X';
		cout << endl;
	}
}

void main()
{
	// shape x(1, 2, 3);   		// error: can't instantiate abstract object
	const int N = 3;    		// number of shapes array of pointers to shapes
	shape* sharray[N] = { &bowl(10, 0, 3), &square(20, 1, 5), &cap(30, 1, 7) };

	cout << endl << endl;    	// start two lines down
	for(int j=0; j<N; j++)   	// display all three shapes
	sharray[j]->draw();
	getch();
}

हम उस Class के Objects Create नहीं कर सकते हैं, जिसमें Virtual Function Declare किया गया होता है और हम इस Class के लिए ऐसे Function Call भी नहीं लिख सकते हैं, जो इस Class के Objects को By Value Function में Pass या Return करते हैं। यानी हम main() Function में निम्न Functions Declare नहीं कर सकते हैं:

void func(shape);  // error
  or
shape func();      // error

Compiler जानता है कि By Value Function में Object को Pass या Return करने पर एक Temporary Object Create होता है और Compiler एक Abstract Class के Object Create नहीं करने देता है। लेकिन यदि Object को Function में By Reference या By Address Pass या Return किया जाता है, तब Compiler को कोई फर्क नहीं पडता है, क्योंकि वास्तव में Pointers Derived Class के Objects को Point करता है।

Pure Virtual Functions को Compiler के लिए केवल एक Signal के रूप में Use करना कि Class एक Abstract Class है, काफी Illogical लगता है। लेकिन Pure Virtual Functions व Abstract Classes दो अलग Concepts हैं।

यदि हम किसी Base Class का कभी कोई Object Create नहीं करते हैं तो इससे कोई फर्क नहीं पडता है, कि Class में वे Functions रहें, जिन्हें कभी Execute ना किया जा सके, साथ ही परिभाषा के अनुसार एक Abstract Class से Classes को Derived भी किया जा सकता है।

Polymorphism को Use करना सम्भव बनाने के लिए इन Derived Classes को Base Class में Virtual Functions की भी जरूरत होती है। अक्सर इस प्रकार का एक Pure Virtual Function Base Class में कुछ भी नहीं करता है। इस प्रकार का एक Function Pure Virtual Function कहलाता है और ये केवल Compiler को ये बताता है कि Class एक Abstract Class है।

कई बार हम किसी Class को Abstract Class बनाना चाहते हैं लेकिन इन Base Classes को ऐसे Virtual Functions की जरूरत होती है, जिनकी Body नहीं होती है। Base Class के सभी Functions को Derived Class के Functions में Access किया जा सकता है। हम किसी Abstract Class के लिए ऐसा Pure Virtual Function भी Create कर सकते हैं, जिसकी Body होती है। ये Function भी Pure Virtual Function की तरह ही Create किए जाते हैं, जिसकी Body नहीं होती है। (Pure Virtual Function in C++ – ProgrammerInterview)

इसे समझने के लिए हम निम्नानुसार एक Employee Class को ले रहे हैं। ये वही Employee Class है जिसे हमने पिछले अध्‍याय में देखा है। हम इसके getdata() Member Function में ही परिवर्तन कर रहे हैं। ये परिवर्तन निम्नानुसार है:

	virtual void getdata() = 0
	{
	   employee::getdata();
	   cout << “ Enter title: ";  cin >> title;
	   cout << “ Enter golf club dues: ";  cin >> dues;
	}