सर्पिल पढ़ने का नियम

"क्लॉक वाइज / सर्पिल नियम" के रूप में जानी जाने वाली तकनीक किसी भी प्रोग्रामर को किसी भी सी भाषा घोषणा को पार्स करने की अनुमति देती है।



इन सरल चरणों का पालन करें:



1. एक अज्ञात तत्व से शुरू, एक सर्पिल / घड़ी की दिशा में आगे बढ़ें; उसी समय निम्नलिखित तत्वों को उपयुक्त वाक्यांशों से बदलें:

• [X] या [] => आकार का एक प्रकार X का प्रकार ... या प्रकार का अपरिभाषित आकार ...
• (टाइप 1, टाइप 2) => टाइप टाइप 1, टाइप 2 को स्वीकार करने और लौटने का कार्य ...
• * => सूचक को ...

2. सभी तत्वों के पूरा होने तक एक सर्पिल / घड़ी की दिशा में आगे बढ़ें।

3. हमेशा पहले कोष्ठकों में अभिव्यक्तियों की अनुमति दें!

उदाहरण 1: सरल विज्ञापन

+-------+<br>

| +-+ |<br>

| ^ | |<br>

char *str[ 10 ];<br>

^ ^ | |<br>

| +---+ |<br>

+-----------+<br>









हम अपने आप से पूछते हैं कि क्या है?

str है ...

हम एक सर्पिल / घड़ी की दिशा में आगे बढ़ते हैं, जो str से शुरू होता है, और पहला चरित्र जो हम देखते हैं, वह '[' है, फिर यह एक सरणी है, और इसी तरह:

str आकार के 10 प्रकार का एक सरणी है ...

हम एक सर्पिल / दक्षिणावर्त में आगे बढ़ना जारी रखते हैं, और अगली चीज जो हम मिलते हैं वह प्रतीक '*' है, जिसका अर्थ है कि हमारे पास संकेत हैं, और इसी तरह:

str आकार 10 की एक सरणी है, पॉइंटर को टाइप करें ...

हम एक सर्पिल में चलते हैं और रेखा के अंत को देखते हैं, इसलिए हम आगे बढ़ते हैं और 'चार' प्रकार देखते हैं, और इसी तरह:

str एक प्रकार का आकार है, जो 10 प्रकार के पॉइंटर से चार के आकार का है।

हमने सभी तत्वों का दौरा किया, अर्थात बस इतना ही, हमने यह अभिव्यक्ति की है!

उदाहरण 2: एक फंक्शन पॉइंटर घोषित करना

+--------------------+<br>

| +---+ |<br>

| |+-+| |<br>

| |^ || |<br>

char *(*fp)( int , float *);<br>

^ ^ ^ || |<br>

| | +--+| |<br>

| +-----+ |<br>

+------------------------+<br>







अपने आप से पूछो, एफपी क्या है?

fp है ...

हम एक सर्पिल / घड़ी की दिशा में आगे बढ़ते हैं, और पहली चीज जो हम देखते हैं वह है ')'; इसलिए fp कोष्ठक के अंदर है और हम कोष्ठक के अंदर सर्पिल को जारी रखते हैं और अगला वर्ण '*' है, और इसी तरह:

fp एक सूचक है ...

हम अब कोष्ठक के बाहर हैं और, एक सर्पिल में आगे बढ़ना जारी रखते हैं, हम देखते हैं '(', यानी यह एक फ़ंक्शन है, और इसी तरह:

fp एक फंक्शन का पॉइंटर होता है जो एक int और एक पॉइंटर को एक फ्लोट में ले जाता है जो वापस लौटता है ...

एक सर्पिल में आगे बढ़ना, हम '*' के प्रतीक से मिलते हैं, और इसी तरह:

fp एक फ़ंक्शन के लिए एक पॉइंटर है जो एक int और एक फ्लोटर के लिए एक पॉइंटर लेता है जो एक पॉइंटर को लौटाता है ...

एक सर्पिल में जारी रखते हुए, हम प्रतीक का सामना करते हैं '?', लेकिन चूंकि सभी प्रतीकों को अभी तक संसाधित नहीं किया गया है, हम जारी रखते हैं और 'चार' का सामना करते हैं, और इसी तरह:

fp एक फ़ंक्शन के लिए एक पॉइंटर है जो एक int और एक फ्लोटर के लिए एक पॉइंटर लेता है जो एक पॉइंटर को एक पॉइंटर लौटाता है।

उदाहरण 3: अंतिम

+-----------------------------+<br>

| +---+ |<br>

| +---+ |+-+| |<br>

| ^ | |^ || |<br>

void (*signal( int , void (*fp)( int )))( int );<br>

^ ^ | ^ ^ || |<br>

| +------+ | +--+| |<br>

| +--------+ |<br>

+----------------------------------+<br>







हम खुद से पूछते हैं कि सिग्नल क्या है?

ब्रैकेट के अंदर सिग्नल पर ध्यान दें, इसलिए पहले आपको अभिव्यक्ति को अंदर पार्स करने की आवश्यकता है! एक सर्पिल / दक्षिणावर्त दिशा में घूमते हुए, हम देखते हैं '(', और इसी तरह:

संकेत एक फ़ंक्शन है जो int और ...

हम्म, हम प्रतीक 'fp' पर समान नियम का उपयोग कर सकते हैं, और इसलिए fp क्या है? fp कोष्ठक के अंदर भी है, इसलिए हम '*' को जारी रखते हैं और देखते हैं:

fp एक सूचक है ...

एक सर्पिल / दक्षिणावर्त दिशा में घूमते हुए, हम देखते हैं '(', और इसी तरह:

fp एक फ़ंक्शन के लिए एक पॉइंटर है जो एक int लेता है, रिटर्न करता है ...

एक सर्पिल / दक्षिणावर्त दिशा में चलते हुए, हम 'शून्य' देखते हैं, और इसी तरह:

fp एक फ़ंक्शन के लिए एक पॉइंटर है जो एक इंट लेता है जो शून्य देता है।

हम fp के साथ किया जाता है, तो चलो संकेत के साथ जारी है, और अब हमारे पास है:

संकेत - एक फ़ंक्शन जो एक int और एक सूचक को एक फ़ंक्शन के लिए लेता है जो एक int लेता है, शून्य देता है, रिटर्न ...

हम अभी भी कोष्ठक के अंदर हैं, इसलिए अगला वर्ण '*' है, और इसी प्रकार:

संकेत - एक फ़ंक्शन जो एक इंट और एक पॉइंटर को एक फ़ंक्शन में ले जाता है जो एक इंट लेता है, शून्य देता है, एक पॉइंटर लौटाता है ...

हमने कोष्ठक के अंदर तत्वों को अनुमति दी, एक सर्पिल में जारी रखते हुए हमें प्रतीक मिलता है '(', और इसी तरह:

सिग्नल - एक फ़ंक्शन जो एक इंट और एक पॉइंटर को एक फंक्शन में ले जाता है जो एक इंट लेता है, शून्य देता है, एक पॉइंटर को एक फंक्शन में देता है जो एक इंट लेता है और एक रिटर्न देता है ...

अंत में, हम आगे बढ़ना जारी रखते हैं, और अंतिम चरित्र के साथ हम 'शून्य' देखते हैं, और इसलिए, हमारा पूरा विवरण इस प्रकार है:

सिग्नल - एक फ़ंक्शन जो एक इंट और एक पॉइंटर को एक फंक्शन में ले जाता है जो एक इंट ले जाता है, शून्य लौटाता है, एक सूचक को एक फ़ंक्शन पर लौटाता है जो एक इंट लेता है और एक शून्य लौटाता है।

यह नियम कब्ज और अस्थिर विशेषताओं को समझने के लिए भी लागू होता है। उदाहरण के लिए:

const char * chptr;

तो क्या chptr है?

chptr अपरिवर्तनीय है।

इसके बारे में क्या:

char * const chptr;

तो क्या chptr है?

chptr char का अपरिवर्तनीय सूचक है।

और अंत में:

वाष्पशील चर * const chptr;

तो क्या chptr है?

chptr अस्थिर करने के लिए एक अपरिवर्तनीय सूचक है।