GOTO का निषिद्ध फल मीठा है!

आपका दिन शुभ हो!

C / C ++ में गोटो ऑपरेटर के लिए आपका दृष्टिकोण क्या है? सबसे अधिक संभावना है, जब आपने प्रोग्राम करना सीखा, तो आपने इसका उपयोग किया। तब आपको पता चला कि यह खराब था, और आप इसके बारे में भूल गए। हालांकि कभी-कभी जटिल त्रुटि से निपटने के साथ ... नहीं, नहीं, वहां कोशिश करें ... फेंकें ... पकड़ें। या नेस्टेड छोरों से बाहर निकलने के लिए ... नहीं, झंडे और बहुत सारी कठिनाइयां हैं। या जब नेस्टेड स्विच ... नहीं, नहीं, नहीं, वही झंडे हैं।
और फिर भी, कभी-कभी रात के सन्नाटे में आपने अपने अवचेतन मन में एक पापपूर्ण विचार की अनुमति दी - " यहाँ गोटो का उपयोग क्यों नहीं किया जाता है ?" और कार्यक्रम पतला लगता है, और आशावादी रूप से सामने आता है। हाँ, यह अच्छा होगा ... लेकिन नहीं - यह असंभव है , वे भूल गए! "
ऐसा क्यों है?
कई वर्षों के अनुभव और विभिन्न प्लेटफार्मों के आधार पर, कट के तहत इस मुद्दे पर एक छोटी सी जांच और इस मुद्दे पर मेरा दृष्टिकोण है
UPD: यहाँ लेख C और C ++ की चर्चा करता है, पीसी के लिए प्रोग्रामिंग और माइक्रोकंट्रोलर के लिए थोड़ा। विशेष रूप से माइक्रोकंट्रोलर के बारे में एक और लेख है ।

गोटो के कट्टर विरोधियों से अनुरोध करें - मुझे केवल कर्म के नरक की आग में न उखाड़ फेंकें क्योंकि मैंने इस विषय को उठाया और गोटो का आंशिक समर्थक हूं!

एक छोटा सा ऐतिहासिक भ्रमण

उन लोगों के लिए जो पहले से ही पूरी तरह से अच्छी तरह से जानते हैं कि एक कॉम्बिनेशन सर्किट, मेमोरी के साथ एक सर्किट और यह कैसे असेंबलर से विकसित हुआ, आप सुरक्षित रूप से आगे छोड़ सकते हैं - निष्कर्ष तक।

और यह सब कॉम्बिनेशन सर्किट के साथ शुरू हुआ

शुरुआत में शब्द था - और शब्द एक फ़ंक्शन था। यह इतना महत्वपूर्ण नहीं है कि यह एक तार्किक चर का बूलियन कार्य था - फिर इस आधार में वे सभी (लगभग) गणित, और फिर ग्रंथों, ग्राफिक्स को लागू करने में कामयाब रहे ... वैसे भी, यह पता चला कि कंप्यूटर प्रौद्योगिकी का उपयोग करना बहुत सुविधाजनक है अंकगणित, और फिर त्रिकोणमितीय और अन्य क्रियाएं और एक चर के कार्यों के मूल्यों को खोजते हैं।

दूसरे शब्दों में, आपको एक ऐसा उपकरण बनाने की आवश्यकता है, जो चर के मान से, फ़ंक्शन का मान पाए।

इस कठिन समस्या को हल करने के लिए, अंकगणितीय ऑपरेशन करने के लिए एक अनुक्रमिक एल्गोरिथ्म का निर्माण किया गया था (इस तरह के एल्गोरिथम में गणना की एक सटीकता के मामले में, प्रत्येक अंकगणितीय ऑपरेशन एक घड़ी चक्र में किया जा सकता है)।

एक एल्गोरिथ्म होने के साथ, एक कॉम्बिनेशन सर्किट का निर्माण करना मुश्किल नहीं है - एक सर्किट जो तुरंत (तर्क उपकरणों के संचालन तक और संकेतों के प्रसार समय तक) आउटपुट पर एक उत्तर देता है।
सवाल है - क्या आपको यहां किसी बदलाव की जरूरत है? नहीं, वे बस वहां नहीं हैं। कार्रवाई का एक सुसंगत पाठ्यक्रम है। अंततः, इन सभी कार्यों को एक ही घड़ी चक्र में लागू किया जा सकता है (मैं यह तर्क नहीं देता, यह बहुत, बहुत ही बोझिल होगा, लेकिन सभी आंकड़ों की थोड़ी गहराई को देखते हुए, कोई भी छात्र आपके लिए ऐसी योजना का निर्माण करेगा, अकेले VHDL या वेरिलॉग के लिए एक सिंथेसाइज़र बनाएं)।

लेकिन फिर मेमोरी सर्किट में हस्तक्षेप हुआ

और फिर किसी का स्मार्ट हेड एक प्रतिक्रिया सर्किट के साथ आया - उदाहरण के लिए, एक आरएस ट्रिगर। और फिर सर्किट की स्थिति दिखाई दी। और राज्य स्मृति के साथ सभी तत्वों के वर्तमान मूल्य के अलावा कुछ भी नहीं है।

ऐसे मेमोरी तत्वों के आगमन ने हार्ड-वायर्ड डिवाइसों से फर्मवेयर तक एक क्रांतिकारी छलांग आगे करना संभव बना दिया। इसे सीधे शब्दों में कहें, तो फर्मवेयर में एक कमांड मेमोरी होती है। एक अलग उपकरण है जो वर्तमान फर्मवेयर (इसके अलावा, घटाव, या कुछ और) को लागू करता है। लेकिन "वर्तमान" फर्मवेयर की पसंद एक अलग डिवाइस है - इसे "नमूना डिवाइस" होने दें।

सवाल यह है कि क्या कोई संक्रमण हैं? निश्चित रूप से हाँ! इसके अलावा, बिना शर्त संक्रमण दिखाई देते हैं (अगले कमांड का पता डेटा की वर्तमान स्थिति पर निर्भर नहीं करता है) और सशर्त (अगले कमांड का पता डेटा की स्थिति पर निर्भर करता है)।

क्या उनके बिना ऐसा करना संभव है? कोई रास्ता नहीं! यदि हम बदलावों का उपयोग नहीं करते हैं, तो हम बिना मेमोरी के कॉम्बिनेशन सर्किट में लौट आएंगे।

परिणामस्वरूप, हम असेंबलर के पास आए

ऐसे कंप्यूटिंग उपकरणों के एपोथोसिस सूक्ष्म, सरल और सुपर कंप्यूटर बन गए हैं। वे सभी मूल रूप से एक कोड भाषा पर आधारित होते हैं जिन्हें लगभग समान आदेशों के साथ आसानी से कोडांतरक में बदला जा सकता है। I386 प्रोसेसर से असेंबलर के साथ सबसे लोकप्रिय पर्सनल कंप्यूटर लें - ठीक है, इसके लिए विंडोज एक्सपी लिखा गया है। उनका काम कैसे संरचित है?

इस प्रोसेसर में, डेटा और निर्देशों की मेमोरी साझा की जाती है, पते से पहचाना जाता है। टीमों की एक निश्चित लंबाई नहीं होती है। यदि जंप कमांड का उपयोग नहीं किया जाता है, तो अगला कमांड वर्तमान के तुरंत बाद स्थित कमांड को निष्पादित करता है।

गोटो कमांड का एक सेट भी है। वे बिना शर्त (बस अगले पते पर स्विच कर रहे हैं - जेएमपी, एक सबप्रोग्राम - कॉल पर स्विच करना, इसे बाहर निकालना - रिट, एक रुकावट - इंट) और सशर्त (झंडे की स्थिति के आधार पर - jnz, jne, jz, ...)। लूप बनाने के लिए एक कमांड भी है - लूप। यह 1) सीएक्स / ईसीएक्स रजिस्टर के लिए -1 करता है और 2) निर्दिष्ट पते पर जाता है यदि यह रजिस्टर नॉनजरो है।
संक्रमण के संचालन के संदर्भ में, अन्य द्रव्यमान कोडांतरक (समान माइक्रोकंट्रोलर) मौलिक रूप से भिन्न नहीं होते हैं - जब तक कि प्रोग्राम को बाधित करने का कोई तरीका नहीं है और हर जगह लूप नहीं है।
मैं सभी जिम्मेदारी के साथ घोषणा करता हूं - असेंबलर में संक्रमण के संचालन के बिना करना असंभव है! कोडांतरक में किसी भी कार्यक्रम बस उन्हें चकाचौंध! हालांकि, कोई भी मेरे साथ यहां बहस नहीं करता है, मुझे लगता है, नहीं करेगा।

परिणाम

क्या कहा जा सकता है? माइक्रोप्रोसेसर स्तर पर, संक्रमण संचालन बहुत सक्रिय रूप से उपयोग किया जाता है। एक वास्तविक कार्यक्रम लिखना लगभग असंभव है जो उनका उपयोग नहीं करता है (शायद यह किया जा सकता है, लेकिन यह एक सुपर-मेगा-विकृति होगी और निश्चित रूप से वास्तविक कार्यक्रम नहीं है!)। कोई भी इसके साथ बहस नहीं करेगा।

लेकिन, फिर, उच्च-स्तरीय भाषाओं में - C / C ++ पर ध्यान केंद्रित करने के कारण - क्या गोटो ऑपरेटर अचानक एहसान से बाहर हो गया? ..?

एल्गोरिदम के बारे में थोड़ा सा

अब एक मुश्किल एल्गोरिदम को देखते हैं। मुझे नहीं पता कि यह किस तरह की बकवास है - लेकिन इसे लागू करने की आवश्यकता है।

UPD : यहाँ A, B, C, D, E कुछ ऑपरेशन हैं , लेकिन फंक्शन कॉल नहीं! यह संभव है कि वे बहुत सारे स्थानीय चर का उपयोग करें। और संभव है कि वे अपना राज्य बदल लें। यही है, इस मामले में हम कॉलिंग फ़ंक्शन के बारे में बात नहीं कर रहे हैं - कुछ क्रियाएं विस्तृत नहीं होंगी।

यहाँ यह ग के साथ C में कैसा दिखता है:

if (a)
{
	A;
	goto L3;
}
L1:
if (b)
{
L2:
	B;
L3:
	C;
	goto L1;
}
else if (!c)
{
	D;
	goto L2;
}
E;
 

. — ! goto:

char bf1, bf2, bf3;

if (a)
{
	A;
	bf1 = 1;
}
else
	bf1 = 0;

bf2 = 0;
do
{
	do
	{
		if (bf3 || b)
			bf3 = 1;
		else
			bf3 = 0;
		if (bf3 || bf2)
			B;
		if (bf3 || bf1 || bf2)
		{
			C;
			bf1 = 0;
			bf2 = 1;
		}
		if (!bf3)
		{
			if (!c)
			{
				D;
				bf3 = 1;
			}
			else
			{
				bf3 = 0;
				bf2 = 0;
			}
		}
	}
	while (bf3);
}
while (bf2);

E; 

- ?..
:

• 5 , .
• goto 2 .
• goto . – , .
• ?
• , , 100%. … .
• .

goto!

, . .

goto

20- , ActiveHDL, , , ( , ). , - . , , – — , .

… , .

goto

, goto – . for (…), while (…) {…}, do {…} while (…). switch (…) {case … case …}. / break continue. , funct() return.

++ , . – try {… throw …} catch (…) {…}.

goto «» — goto?

goto

, , . . – , !

– .
– , - , . ! , ++ ? ++ («» , ): , , , , … , ++… , , – « ».

, – ? - . 220 – ! – .

goto. – .

– , , . ? – , ! , - ! , – . !

, , a = ++i , i = i + 1; a = i. , ?

, C++ , goto :

goto Label;

for (;;)
{
	int p = 0;
Label:
	p += 10;
}

p? ! , – , p .

– Visual Studio 2008.
? , - goto . , . .

++ try … throw … catch. . ++ — , . goto. , . – , , .

, goto. «» , UART, USB . .

:

char a, b, c;

for (a = 0; a < 10; ++a)
{
	for (b = 0; b < a; ++b)
	{
		if (!c)
			goto Leave;
	}
	for (b = 10; b < 15; ++b)
	{
		d ();
	}
}

Leave:
e ();

– ? . - – .

:

char a, b, c, f1;

f1 = 1;
for (a = 0; a < 10 && f1; ++a)
{
	for (b = 0; b < a && f1; ++b)
	{
		if (!c)
			f1 = 0;
	}
	if (f1)
	{
		for (b = 10; b < 15; ++b)
		{
			d ();
		}
	}
}

e ();

? . . , «» PC. – .

, ( , Java) break Leave. goto, !

switch (…) { case …}. .

UPD: , , ++. ++ «» throw… catch…. , throw… catch… — goto!

? ? , ( boost::spirit). , « » — , ; , . goto …

, ++ , . . , , goto?.. – , . . – .

- :

int f (…)
{
	…
	if (a)
	{
		c = 15;
		return 10;
	}
	…
	if (b)
	{
		c = 15;
		return 10;
	}
	…
	 = 10;
	return 5;
}

:

int f (…)
{
	…
	if (a)
		goto Exit;
	…
	if (b)
		goto Exit;

	…
	 = 10;
	return 5;
Exit:
	c = 15;
	return 10;
}

? - . . goto. .
, …

! . – , !

, , goto .
– goto .

UPD: , goto .

goto:

• ( . . ) switch… case
• : ( )
• ,

goto:

• ( , , )
• ( )

/? , .