Initialize Member Array

Initialize Member Array Size

एक Array के साथ Constructors का प्रयोग करने पर काफी समस्याऐं Generate हो जाती हैं। किसी Array की Size तय करने के लिए हम सामान्‍यतया निम्नानुसार Declarations करते हैं:

class Stack
{
   private:
	  int st[20];
	  int top;
   …
};

इस तरह का Declaration हालांकि अच्छी तरीके से काम करता है लेकिन जब हम कोई Real Program बना रहे होते हैं, तब हमें Program में कई Member Functions में इसी Size 20 की जरूरत पडती है। मानलो कि हम ये तय करना चाहते हैं कि हम 20 से अधिक मानों को Stack में Push ना कर सकें। जैसे ही Stack में 21 वां Element Push किया जाए, तो Error Message Display हो, तो हमें ये काम निम्नानुसार करना होगा:

void push(int Value)
{
	if(top++ > 20)
		cout << “Error”, Overflow” ;
	else
		st(++top) = Value;
}

अब हम देख सकते हैं कि मान 20 का प्रयोग Class में दो बार हुआ है और ये एक सामान्‍य सम्भावना है कि यदि हम Array की Size एक जगह पर बदल दें, तो भी सभी जगहों पर Array की Size Change करेंगे, इसकी सम्भावना कम ही होती है। कहीं ना कहीं पर हम मान को बदलना भूल जाएंगे। साथ ही यहां पर केवल दो ही बार मानों को Change करना है लेकिन यदि एक Program में 200 बार इस मान को Change करना हो, तो काफी दिक्कत हो जाएगी।

चूंकि हम जानते हैं कि Array एक Static Data Structure है यानी इसकी Size Program की शुरूआत में ही निश्चित कर दी जाती है, इसलिए यदि हम इसकी Size को एक Constant द्वारा Represent करें, तो ज्यादा बेहतर होगा। क्योंकि यदि हम उस Constant का मान Change करेंगे, तो पूरे Program में उस Constant का जहां&जहां प्रयोग हुआ है, उन सभी स्थानों पर Array की Size का मान Change हो जाएगा।

Constant Size Define करने के लिए हम External Constant Variable का प्रयोग कर सकते हैं। ये एक Global Variable होता है और हम इसे निम्नानुसार Class से बाहर Define कर सकते हैं, ताकि पूरे Program का कोई भी हिस्सा इसका प्रयोग कर सके।

const int SIZE = 20;
class Stack
{
	Private:
		int stack[SIZE];
		int top;
	public:
void push(int Value)
{
	if(top++ > SIZE)
		cout << “Error”, Overflow” ;
	else
		st(++top) = value;
}

हालांकि ये तरीका भी काम करता है लेकिन इस तरीके में OOPS के Encapsulation Concept का पालन नहीं होता है, क्योंकि Data व उसके Operations दोनों एक Unit के रूप में नहीं हैं। इसलिए इस Constant को हमें Class के अन्दर Define करना होता है, ताकि इसे Class के Objects के Member Function के अलावा Program का कोई भी हिस्सा Use ना कर सके। यानी हम निम्नानुसार Class को Constant Size Variable के साथ Define कर सकते हैं:

class Stack
{
	Private:
		const int SIZE = 20;	// Illegal Initialization 
		int stack[SIZE];
		int top;

	public:
	void push(int Value)
	{
		if(top++ > SIZE)
			cout << “Error”, Overflow” ;
		else
			st(++top) = value;
	}
}

जैसाकि हमने पहले ही कहा कि हम किसी Class के Private Data Members को इस प्रकार से Initialize नहीं कर सकते हैं, इसलिए ये Statement यहां भी काम नहीं करेगा और Compiler निम्नानुसार एक Error Generate करेगा-

Cannot initialize a class Member here.

ये Error इसलिए Generate होगा क्योंकि Class के Data Members को केवल Constructors के प्रयोग द्वारा ही Initialize किया जा सकता है। आप सोंच सकते हैं कि एक Non Member Data की तरह ही हम किसी Class के Data Members को Equal To Assignment Operator का प्रयोग करते हुए Initialize क्यों नहीं कर सकते हैं?

तो इस सवाल का जवाब ये है कि Class के हर Instance के लिए ये Instance Variables अलग-अलग होते हैं। इसलिए किस Object के Instance Variable को Initialize करना है, ये किसी Object के Instance Data को केवल Object के Create होते समय ही Initialize किया जा सकता है और हम ये काम Constructors का प्रयोग करके ही कर सकते है।

क्योंकि Constructor एक ऐसा Member Function होता है जो किसी Object को Create करते समय ही Execute होता है, इसलिए ये हर Object के लिए केवल एक ही बार Execute होता है। इसलिए किसी Class के Data Member को Initialize करने के लिए हमें निम्न तरीका ही उपयोग में लेना पडता है:

class Stack
{
	Private:
		const int SIZE;	 
		int stack[SIZE];
		int top;

	public:
		Stack(int size) : SIZE(size) { } 

	void push(int Value)
	{
		if(top++ > SIZE)
			cout << “Error”, Overflow” ;
		else
			st(++top) = value;
	}
};

किसी Constant Variable को Initialize करने के लिए हम किसी Constructor की Body में Assignment Statement का प्रयोग नहीं कर सकते हैं क्योंकि Assignment का मतलब होता है कि हम किसी Variable में पहले से स्थित किसी मान में परिवर्तन कर रहे हैं, ना कि उस Variable को पहला मान प्रदान कर रहे हैं और दूसरी बात ये कि const Variable के मान को Change भी नहीं किया जा सकता है। यानी हम किसी Constant Variable को निम्नानुसार Initialize नहीं कर सकते हैं:

class Stack
{
Private:
const int SIZE;	 
	int stack[SIZE];
	int top;
 
public:
Stack(int size) { SIZE = size; }

मानलो कि हमने निम्नानुसार Constant Variable को उचित तरीके से Initialize भी कर दिया लेकिन फिर भी हम इस Constant Variable को Array की Size Define करने के लिए Use नहीं कर सकते हैं।

class Stack
{
	Private:
	    const int SIZE ;	//Legal Initialization 
	    int stack[SIZE];
	    int top;
  
	public:
		Stack(int size) : SIZE (size) { }	//Size Initialized 
	};

यहां ये परेशानी है कि Array की Size Compiler को Program Compile होते समय पता होनी चाहिए। जबकि इस Class का जब Object Create किया जाएगा, तब ही Object के Array का SIZE Variable Initialize होगा और बिना Array की Size Define हुए] Program Compile नहीं होगा।

यानी सारांश में कहें तो हम किसी साधारण Instance Variable की तरह Array की Size को Define नहीं कर सकते हैं। इस समस्या के समाधान के लिए enum का निम्नानुसार प्रयोग कर सकते हैं, हालांकि ये तरीका भी उचित नहीं है।

	class Stack
	{
		Private:
			enum {SIZE = 20 }; 
			int stack[SIZE];
			int top;
  
	public:
	};

ये तरीका ठीक काम करता है। Compiler Compile Time में SIZE का मान 20 तय करता है और उस मान के आधार पर Array की Size Define कर लेता है।

चूंकि enum के प्रयोग को Array की Size Define करने के लिए उचित नहीं कहा जा सकता इसलिए “C++” में Static Constant Instance Variable को Initialize करने के लिए एक नए Constructor को Add किया गया। यानी अब हम enum के स्थान पर निम्नानुसार एक Constant Instance Variable को Class में Declare कर सकते हैं:

	class Stack
	{
		private:
		static const int SIZE = 20; 		//Static Constant
			int stack[SIZE];
			int top;
  
		public:
	};

इस Class में SIZE एक Constant है इसलिए इसके मान को Change नहीं किया जा सकता है, लेकिन चूंकि ये एक Static Variable भी है और इसे Compile Time में एक मान भी दिया गया है, इसलिए इसे Array की Size Define करने के लिए Use किया जा सकता है।

हालांकि कई Compilers में इस नए Constructor को Add नहीं किया गया है। इसलिए जिन Compilers में ये Statement Error Generate करता है, उन Compilers में enum का ही प्रयोग करना चाहिए।

Initialize Member Array Elements

किसी Class के Instance Variable के रूप में Declare किए गए Array के Element को भी यदि Initialize करना हो, तो हम साधारण तरीके से Initialize नहीं कर सकते हैं और ना ही Constructor का प्रयोग करके कर सकते हैं। यानी हम निम्नानुसार किसी Instance Array को Initialize नहीं कर सकते हैं:

WeekDay() : dayName[0] (“Sunday”), dayName[1] (“Monday”), . . . { }

हम किसी Instance Array को इस तरह से इसलिए Initialize नहीं कर सकते हैं क्योंकि Compiler केवल Initialization List के Individual Variable को ही इस तरह से Initialize कर सकता है, किसी Array को नहीं। हमने देखा है कि हम किसी Non – Static Instance Data को निम्नानुसार Initialize नहीं कर सकते हैं:

	class WeekDay
	{
		private :
			char dayName[DPW][MAX] = { “Sunday”, “Monday”, . . . }
	}

इस स्थिति में हमें Instance Array को Static रखना जरूरी हो जाता है, क्योंकि ये Instance Array सभी Objects के लिए Static होता है। जब एक Array Static होता है तब Array को उसके Definition के समय Initialize किया जा सकता है। यानी:

class WeekDay
{
	private :
		static const char dayName[DPW][MAX];		// Declaration 
};

const char WeekDay :: dayName[DPW][MAX] =	         	// definition
{
	"Sunday", "Monday", "Tuesday", 
	"Wednesday", "Thursday",
	"Friday", "Saturday" 
};

इस तरीके का प्रयोग करके हम किसी Instance Array को Initialize कर सकते हैं। इस प्रक्रिया में हमें class के अन्दर केवल Array का Declaration करना होता है। Array का Definition Class के बाहर Scope Resolution Operator का प्रयोग करके किया जाता है, क्योंकि Array के Elements Private Area में हैं।