C में विज्ञापन कैसे पढ़ें

यहां तक ​​कि पूरी तरह से हरे सी प्रोग्रामर को इन घोषणाओं को पढ़ने में कोई परेशानी नहीं है:
int foo[5]; // foo 5 int
char *foo; // foo char
double foo(); // foo double

लेकिन जैसे ही विज्ञापनों को थोड़ा और अधिक जटिल लगता है, यह कहना मुश्किल है कि यह वास्तव में क्या है। उदाहरण के लिए:
char *(*(**foo[][8])())[];


यह पता चला है कि मनमाने ढंग से समग्र घोषणाओं को पढ़ने के नियम नौसिखिए प्रोग्रामर द्वारा भी आसानी से सीखे जाते हैं (हालांकि इस तरह के घोषित चर का उपयोग करना असंभव है)।

मूल और व्युत्पन्न प्रकार

चर नाम के अलावा, घोषणा में एक मुख्य प्रकार होता है और इसमें एक व्युत्पन्न प्रकार भी हो सकता है, और यह उनके बीच के अंतर को समझने की कुंजी है।

मुख्य प्रकार हैं:
• चार
• हस्ताक्षरित चार
• अहस्ताक्षरित चार
• छोटा
• अहस्ताक्षरित लघु
• इंट
• अहस्ताक्षरित int
• लंबा
• लंबे समय तक अहस्ताक्षरित
• तैरता है
• डबल
• लंबी डबल
• शून्य
• संरचना टैग
• संघ टैग
• एनम टैग
• लंबे समय तक
• लंबे समय तक अहस्ताक्षरित

एक विज्ञापन में केवल एक मुख्य प्रकार हो सकता है , और यह हमेशा अभिव्यक्ति के बाईं ओर होता है। मूल प्रकार व्युत्पन्न प्रकारों के पूरक हैं, सी में उनमें से तीन हैं:

1) * - सूचक को ...
यह * द्वारा दर्शाया गया है, और यह समझना महत्वपूर्ण है कि सूचक हमेशा किसी चीज़ की ओर इशारा करता है।

2) [] - की एक सरणी ...
एक सरणी आयाम रहित हो सकती है - [], या यह आयामी हो सकती है [१०]। एक आयामी सरणी सही है या नहीं, यह विज्ञापन पढ़ते समय मायने नहीं रखता (आमतौर पर सरणी का आकार अभी भी लिखा जाता है)। यह स्पष्ट होना चाहिए कि एक सरणी हमेशा एक "कुछ की सरणी" होती है।

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

व्युत्पन्न प्रकार हमेशा कुछ को संशोधित करते हैं, यह मुख्य प्रकार या व्युत्पन्न एक हो सकता है, और घोषणाओं को सही ढंग से पढ़ने के लिए, आपको हमेशा एक पूर्वसर्ग डालना होगा ("पर", "से", "वापस")। पढ़ते समय एक "पॉइंटर" के बजाय "पॉइंटर" का उपयोग करना, आप निश्चित रूप से घोषणा को सही ढंग से नहीं पढ़ेंगे।

प्राथमिकता ऑपरेटरों।

लगभग हर सी प्रोग्रामर ऑपरेटर प्राथमिकता तालिकाओं से परिचित है जो कहते हैं कि (उदाहरण के लिए) गुणन और विभाजन में जोड़ और घटाव की तुलना में उच्च प्राथमिकता (पहले प्रदर्शन) है, और समूहबद्ध कोष्ठक का उपयोग इस प्राथमिकता को बदलने के लिए किया जाता है। यह "सामान्य" विचारों के लिए सामान्य लगता है। , लेकिन विज्ञापनों पर समान नियम लागू होते हैं - वे केवल "विशिष्ट" हैं, कम्प्यूटेशनल नहीं हैं।
ऑपरेटरों "" की सरणी [] और "वापस लौटने" () "सूचक" की तुलना में एक उच्च प्राथमिकता है, जो काफी सरल डिकोडिंग नियम की ओर जाता है:
हमेशा चर नाम से शुरू करें:

फू है .....

और मुख्य प्रकार के साथ डिकोडिंग खत्म करें:

... इंट की तरह

बीच में क्या होगा आमतौर पर पार्स करना अधिक कठिन होता है, लेकिन एक नियम तैयार किया जा सकता है:
यदि संभव हो तो दाईं ओर ले जाएं और यदि आवश्यक हो तो बाएं घूमें
चर नाम के साथ शुरू करना, प्राथमिकता के नियमों का पालन करना, जहां तक ​​संभव हो दाईं ओर जाएं, जब तक आप समूह कोष्ठक तक नहीं पहुंचते तब तक टोकन को पार करना। उसके बाद, कोष्ठक के अनुसार बाईं ओर ले जाएं।

एक साधारण उदाहरण।

आइए एक सरल उदाहरण से शुरू करें:
-> लंबा ** फू [7];

आइए एक या दो हिस्सों पर ध्यान केंद्रित करके, उन्हें बोल्ड में उजागर करके यह पता लगाने की कोशिश करें, और जो हमने पहले ही तय कर लिया है, हम उसे पार कर लेंगे

-> लंबा ** फू [7];

हम चर नाम से शुरू करते हैं और मुख्य प्रकार के साथ समाप्त होते हैं:
फू है ... जैसे लंबे

हम और भी जुदा होते हैं:
-> लंबा ** फू [7] ;

फिलहाल, चर नाम एक टोकन अर्थ "7 के एक सरणी" और एक टोकन अर्थ "एक सूचक" से घिरा हुआ है, और नियम के अनुसार, दाईं ओर जाएं और हमारे विवरण "7 की एक सरणी" में जोड़ें:
foo एक प्रकार की 7 ... लंबी प्रकार की है

-> लंबा * * फू [7] ;

दाईं ओर जाने के लिए कहीं और नहीं है, और निकटतम टोकन एक "सूचक" है। इसे जोड़ें:
फू 7 बिंदुओं की एक सरणी है ... प्रकार का मान लंबे समय तक

-> लंबा * * फू [7] ;

निकटतम टोकन एक "सूचक" भी है, इसे जोड़ें:
foo टाइप करने के लिए 7 पॉइंटर्स टू पॉइंटर्स टू वैल्यू ऑफ लॉन्ग टाइप है

खैर, यह सब है।

जटिल उदाहरण

हमारे कौशल का परीक्षण करने के लिए, हमें एक बहुत ही जटिल घोषणा को पढ़ने की कोशिश करने की ज़रूरत है जो वास्तविक जीवन में कभी नहीं मिलेगी (वास्तव में, हमने लंबे समय से सोचा था कि इस घोषणा को कैसे लागू किया जाए)। लेकिन हमें यह दिखाने की ज़रूरत है कि नियम बहुत जटिल घोषणाओं के लिए काम करते हैं।

-> चार * (* (** फू [] [8]) ()) [];
सभी घोषणाओं को "चर नाम ... मुख्य प्रकार" के साथ पढ़ा जाना चाहिए
फू है ... चार की तरह ;

-> चार * (* (** फू [] [8]) ()) [];
नाम के समीप "सूचक" और "सरणी" हैं, सही जाएं:
foo एक प्रकार का ... का प्रकार है;

char * (* (** foo [] [8] ) ()) [];
हम दाईं या बाईं ओर के टोकन को चुन सकते हैं, लेकिन नियम कहता है कि आपको जहां तक ​​संभव हो दाईं ओर जाना चाहिए, जबकि समूह के कोष्ठकों के अंदर कुछ समीप है, इसलिए दाएं जाएं।
foo एक प्रकार की सरणी है ... प्रकार की चार;

-> चार * (* (* * फू [] [8] ) ()) [];
हमें समूहीकरण कोष्ठक में मिला है, और आगे दाईं ओर जाना संभव नहीं लगता है, इसलिए जब तक हम बाँधने वाले समूह कोष्ठक तक नहीं पहुँचते हैं, तब तक हम बायें चले जाते हैं।
foo एक प्रकार का व्यूअर है ... टाइप टू का ...;

-> चार * (* ( * * फू [] [8] ) ()) [];
फिर से, बाईं ओर जाएं और "पॉइंटर" को असाइन करें।
foo एक प्रकार का पॉइंट टू पॉइंट ऑफ़ टू पॉइंट ऑफ़ टू टाइप चैर है;

-> चार * (* (** फू [] [8]) () ) [];
जब हमने पिछले चरण में "पॉइंटर" को जोड़ा, तो हमें पेयरिंग कोष्ठक में जोड़ा गया, इसलिए हम "समूहीकरण कोष्ठक" से जुड़े रहेंगे। अब वे दाईं ओर "फ़ंक्शन रिटर्न" और बाईं ओर "पॉइंटर" से सटे हैं। हम दाईं ओर चलते हैं।
foo एक प्रकार के चार बिंदुओं की ओर इशारा करते हुए एक फ़ंक्शन पर लौटने वाले बिंदुओं का एक प्रकार है ... प्रकार चार का;

-> चार * ( * (** फू [] [8]) () ) [];
हम फिर से समूहबद्ध कोष्ठक में भाग गए, इसलिए फिर से हम बाईं ओर वापस जाते हैं।
foo एक प्रकार का संकेत करने के लिए एक समारोह में लौटने वाले बिंदुओं की ओर इशारा करते हैं;

-> चार * (* (** फू [] [8]) ()) [] ;
समूहीकरण कोष्ठक को दरकिनार करते हुए, हम देखते हैं कि अब पार किए गए टोकन दाईं ओर "सरणी" और बाईं ओर "सूचक" से सटे हैं, "सरणी" दाईं ओर है, हम जोड़ते हैं।
foo एक प्रकार का संकेत है, जो एक प्रकार के बिंदु से बिंदु से चार की ओर लौटने वाले एक समारोह में संकेत करने वाले बिंदुओं की ओर से एक सरणी है ;

-> चार * (* (** फू [] [8]) ()) [] ;
खैर, आखिरी टोकन जोड़ें।
foo एक प्रकार का संकेत है जो एक प्रकार्य बिंदु से संकेत करने वाले प्रकार्य बिंदुओं की एक सरणी पर लौटने वाले फ़ंक्शन से पॉइंटर्स से पॉइंटर्स तक है ;

हम वास्तव में इसे लागू करने का तरीका नहीं जानते, लेकिन इसका प्रकार सही है।

सार विज्ञापन

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

int (* (*) ()) () ;

स्वाभाविक रूप से सवाल उठता है कि कहां से शुरू करना है, और इसलिए जवाब इस तरह होगा: "आपको एक जगह खोजने की आवश्यकता है जहां चर नाम खड़ा होगा और इसे नियमित घोषणा के रूप में माना जाएगा"। ऐसी एक ही जगह होगी, और इसे ढूंढना वास्तव में बहुत सरल है। सिंटैक्स नियमों का उपयोग करना जो हम जानते हैं:

• टोकन के सभी "सूचक" के दाईं ओर
• सभी टोकन के बाईं ओर "सरणी"
• सभी टोकन के बाईं ओर "फ़ंक्शन रिटर्न"
• सभी समूहीकरण कोष्ठकों के अंदर

अब एक उदाहरण देखते हैं। हम देखते हैं कि "पॉइंटर टू" टोकन का बायां सेट एक बॉर्डर सेट करता है और "फंक्शन रिटर्न" टोकन का सही सेट बॉर्डर सेट करता है।
int (* (* •) • ()) () ;

लाल बिंदु • संकेत करते हैं कि चर नाम कहाँ रखा जा सकता है, लेकिन केवल एक ही स्थान शर्तों को पूरा करता है (कोष्ठक के अंदर)। और फिर घोषणा के बारे में क्या? और यहाँ है:

int (* (* foo) ()) () ;
हमारे नियम इस प्रकार हैं:
foo एक फ़ंक्शन पॉइंटर है जो एक फ़ंक्शन पॉइंटर लौटाता है एक इंट वैल्यू लौटाता है

शब्दार्थ सीमाएँ / नोट्स

व्युत्पन्न प्रकारों के सभी संयोजनों की अनुमति नहीं है। यह घोषणाओं को बनाने के लिए संभव है जो वाक्य-रचना के नियमों में पूरी तरह से फिट हों, लेकिन फिर भी जो गलत होगा (वे वाक्यविन्यास रूप से सही होंगे, लेकिन उदाहरण के लिए शब्दार्थ गलत हैं)

• कार्यों की एक सरणी बनाने में असमर्थ
लेकिन आप फ़ंक्शन पॉइंटर्स की एक सरणी का उपयोग कर सकते हैं

• समारोह समारोह वापस नहीं कर सकते
लेकिन एक फ़ंक्शन पॉइंटर वापस कर सकता है

• समारोह एक सरणी वापस नहीं कर सकते
फिर से, एक फ़ंक्शन एक पॉइंटर को एक सरणी में वापस कर सकता है

• सरणियों में, केवल बाएं टोकन [] खाली हो सकता है
C बहुआयामी सरणियों (जैसे foo [1] [2] [3] [4]) का समर्थन करता है, जो एक बहुत ही सरल संरचना है। हालांकि, जब किसी सरणी में एक से अधिक आयाम होते हैं, तो केवल पहले ब्रैकेट खाली हो सकते हैं। char foo [] और char foo [] [५] को अस्तित्व का अधिकार है, लेकिन char foo [५] [] को पूरी तरह से छोड़ दिया गया है
• टाइप करें "शून्य" सीमित
"शून्य" प्रकार एक छद्म प्रकार है, और इस प्रकार के चर केवल "सूचक" और "रिटर्निंग रिटर्न" हो सकते हैं। यह "शून्य की सरणी" और "शून्य" प्रकार के बस चर का उपयोग करने के लिए निषिद्ध (या असंभव) है।
शून्य * फू; // अनुमति दी
शून्य फू (); // अनुमति दी
शून्य फू; // निषिद्ध
शून्य फू []; // निषिद्ध

एक कॉल अनुबंध प्रकार जोड़ना

विंडोज़ प्लेटफ़ॉर्म पर विकसित होने पर, इसे अक्सर कॉलिंग कन्वेंशन के फ़ंक्शन वर्णन में जोड़ा जाता है। यह कंप्यूटर को अनुरोध में फ़ंक्शन को कॉल करने के लिए किस विधि का उपयोग करने के लिए कहता है, और फ़ंक्शन की अपेक्षा के अनुसार विधि समान होनी चाहिए। यहाँ यह कैसा दिखता है:

extern int __cdecl main(int argc, char **argv);

extern BOOL __stdcall DrvQueryDriverInfo(DWORD dwMode, PVOID pBuffer,
DWORD cbBuf, PDWORD pcbNeeded);

Win32 के लिए विकास में ऐसा जोड़ बहुत आम है, यह समझना काफी सरल है। अधिक जानकारी के लिए win32 कॉलिंग कन्वेंशन का उपयोग करके लेख देखें।

जहां यह किसी तरह अधिक जटिल हो जाता है, जब कॉलिंग कन्वेंशन को "पॉइंटर" (टाइपडिफ सहित) में शामिल किया जाना चाहिए, क्योंकि टोकन ऐसा नहीं लगता है कि यह सामान्य सर्किट से मेल खाता है। इसका उपयोग अक्सर लोडलॉफ़्ट के साथ काम करते समय किया जाता है। ) और GetProcAddress () हाल ही में भरी हुई लाइब्रेरी से फ़ंक्शन कॉल तक पहुंचने के लिए एपीआई।
यह अक्सर टाइपडिफ के साथ पाया जा सकता है:
typedef BOOL (__stdcall *PFNDRVQUERYDRIVERINFO)(
DWORD dwMode,
PVOID pBuffer,
DWORD cbBuf,
PDWORD pcbNeeded
);

...

/* get the function address from the DLL */
pfnDrvQueryDriverInfo = (PFNDRVRQUERYDRIVERINFO)
GetProcAddress(hDll, "DrvQueryDriverInfo")

कॉल समन्वय एक फ़ंक्शन का एक गुण है, न कि एक पॉइंटर, इसलिए इसे पढ़ते समय, आपको इसे पॉइंटर से पहले रखने की आवश्यकता होती है, लेकिन फिर भी समूहीकरण कोष्ठक के अंदर:

BOOL (__stdcall * foo) (...);

यह लिखा है:
फू __stdcall BOOL लौटाने के लिए एक सूचक है।

पीएस के बारे में गलतियाँ, कृपया पीएम में लिखें।