🧘🏻 ⚜️ 🈚️ हेक्स संपादक संदर्भ सामग्री 010 संपादक: टेम्पलेट्स 📚 👰🏽 📨

010 संपादक ( भाग I , भाग II ) में काम करने के बारे में कुछ लेख लिखने के बाद, मैं इस नतीजे पर पहुंचा कि बुनियादी बातों के बारे में अधिक विस्तार से बताने से, कार्यक्रम से मदद का अनुवाद शुरू करना बेहतर है, क्योंकि इसमें सब कुछ अच्छी तरह से लिखा गया है, लेकिन रूसी अनुवाद नहीं है। इसलिए, इस लेख में हम 010 संपादक टेम्प्लेट लिखने की उन विशेषताओं से परिचित होंगे जिनके बारे में डेवलपर्स खुद बात करते हैं।

बाइनरी टेम्प्लेट 010 संपादक की सबसे शक्तिशाली विशेषताओं में से एक हैं, जो आपको चर और संरचनाओं के एक निर्धारित सेट के रूप में किसी भी फ़ाइल का प्रतिनिधित्व करने की अनुमति देता है। टेम्पलेट नियमित रूप से हेक्स संपादकों की अनुमति से फ़ाइलों को बहुत अधिक सुविधाजनक तरीके से खोजने और संपादित करने में मदद करते हैं। प्रत्येक टेम्प्लेट "* .bt" एक्सटेंशन के साथ एक पाठ फ़ाइल है, जिसे नोटपैड में और सीधे 010 संपादक में संपादित किया जा सकता है (टेम्प्लेट मेनू देखें)। टेम्पलेट को व्याख्यायित कोड के रूप में लॉन्च किया गया है, इसके काम के बाद निष्पादन का परिणाम टेम्पलेट परिणाम पैनल में प्रदर्शित किया गया है। टेम्पलेट्स को स्वचालित लोडिंग और निष्पादन के लिए कॉन्फ़िगर किया जा सकता है जब एक निश्चित एक्सटेंशन वाली फ़ाइल को संपादक में खोला जाता है, उदाहरण के लिए, मानक सेट 010 संपादक में * .zip, * .bmp और * .wav के साथ काम करने के लिए टेम्पलेट शामिल हैं।

I - परिवर्तनीय घोषणा

चर की घोषणा सी के समान है, लेकिन एक महत्वपूर्ण अंतर के साथ: जब भी किसी टेम्पलेट में एक चर घोषित किया जाता है, तो यह फ़ाइल में बाइट्स के एक सेट के लिए इसके प्रतिनिधित्व में "स्थानांतरित" होता है। उदाहरण के लिए, एक टेम्पलेट पर विचार करें:

char header[4]; int numRecords;

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

विशेष गुण

विशेष विशेषताओं को 'कोण' ('<' और '>') कोष्ठक के अंदर घोषित चर के बाद परिभाषित किया जा सकता है। निम्नलिखित विशेषताएँ समर्थित हैं:

  < format=hex|decimal|octal|binary, //  : , , ,  fgcolor=<color>, //   bgcolor=<color>, //   comment="<string>"|<function_name>, //  name="<string>"|<function_name>, //  open=true|false|suppress, //   hidden=true|false, //   read=<function_name>, //    write=<function_name> //    size=<number>|<function_name> > //

सभी विशेषताओं के उद्देश्य के बारे में नीचे चर्चा की गई है, पढ़ने और लिखने के कार्यों के अपवाद के साथ (उन्हें कस्टम वरुअबल्स अनुभाग में चर्चा की गई है), साथ ही आकार (ऑन-डिमांड स्ट्रक्चर्स सेक्शन में चर्चा की गई है)।

प्रदर्शन मोड

डिफ़ॉल्ट रूप से, टेम्पलेट परिणामों में प्रदर्शित सभी चर दशमलव प्रारूप में हैं। आप हेक्साडेसिमल, दशमलव, अष्टक और बाइनरी के बीच स्विच करने के लिए DisplayFormatDecimal, DisplayFormatHex, DisplayFormatBinary और DisplayFormatOctal फ़ंक्शन का उपयोग कर सकते हैं। एक वैकल्पिक तरीका निम्नलिखित विशेषता का उपयोग करना है:

 '<format=hex|decimal|octal|binary>'

एक वैरिएबल या टाइपडिफ़ घोषित करने के बाद। उदाहरण के लिए:

  int id; int crc <format=hex>; int flags <format=binary>;

रंग

टेम्प्लेट का उपयोग करके किसी फ़ाइल को पार्स करते समय, आप हेक्स कोड को विभिन्न रंगों में रंग सकते हैं। उदाहरण के लिए, फ़ाइल शीर्षलेख को शेष फ़ाइल से अलग रंग में प्रदर्शित किया जा सकता है। "रंग" का उपयोग करने के दो तरीके हैं। यदि आप किसी एकल चर का रंग सेट करना चाहते हैं, तो आप वर्णों और पृष्ठभूमि के रंग को सेट करने के लिए विशेषता '<fgcolor = ???>' या '<bgcolor = ???>' का उपयोग कर सकते हैं। तर्क ('???') या तो एक अंतर्निहित रंग स्थिरांक (cBlack, cYellow, cWhile, आदि) हो सकता है, या प्रारूप में एक संख्या '0xBBGGRR' (उदाहरण के लिए, 0xFF0000 नीला)। उदाहरण के लिए:

 int id <fgcolor=cBlack, bgcolor=0x0000FF>;

दूसरा तरीका है SetForeColor, SetBackColor और SetColor फ़ंक्शंस का उपयोग करना। इन कार्यों में से एक के बाद उपयोग किए जाने वाले सभी चर को उनके द्वारा परिभाषित रंग सौंपा जाएगा। 'CNone' निरंतर रंगों के उपयोग को अक्षम करता है। उदाहरण के लिए:

  SetForeColor( cRed ); //     int first; //      int second; //      SetForeColor( cNone ); //      int third; //     -

बाइट ऑर्डर (एंडियन)

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

यह टिप्पणी टेम्पलेट परिणाम फलक के टिप्पणी कॉलम में दिखाई जाएगी। एक मनमाने कार्य को एक टिप्पणी के रूप में भी संकेत दिया जा सकता है: '<टिप्पणी = <function_name >>'। इस तरह के एक फ़ंक्शन तर्कों के रूप में एक चर लेता है और एक स्ट्रिंग देता है जिसे टिप्पणी कॉलम में प्रदर्शित किया जाएगा। उदाहरण के लिए:

  int machineStatus <comment=MachineStatusComment>; string MachineStatusComment( int status ) { if( status <= 15 ) return "*** -  "; else return " "; }

नाम

"नाम" पैरामीटर का उपयोग टेम्पलेट परिणाम पैनल के नाम कॉलम में प्रदर्शित पाठ को बदलने के लिए किया जा सकता है। ऊपर चर्चा किए गए टिप्पणी पैरामीटर की तरह, नाम पैरामीटर '<name = ""> का उपयोग करके सेट किया जा सकता है या इसमें एक मनमाना फ़ंक्शन' <नाम = <function_name >> 'हो सकता है। "नाम" पैरामीटर में फ़ंक्शन का उपयोग करना पैरामीटर में उपयोग करने के बराबर है। "टिप्पणी": यह फ़ंक्शन तर्क के रूप में एक चर लेता है और उदाहरण के लिए एक स्ट्रिंग लौटाता है:

  byte _si8 <name="Signed Byte">;

यह चर टेम्पलेट परिणाम पैनल में "बाइट _si8" के रूप में नहीं, बल्कि "हस्ताक्षरित बाइट" के रूप में प्रदर्शित किया जाएगा। ध्यान दें कि यदि चर एक सरणी का हिस्सा है, तो सूचकांक स्वचालित रूप से सरणी के नाम को सौंपा जाएगा।

चरों का क्रम पढ़ना

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

स्थानीय चर

कुछ मामलों में, आपको उन वेरिएबल्स का उपयोग करना होगा जो टेम्प्लेट परिणाम पैनल में प्रदर्शित नहीं होने चाहिए, और जो फ़ाइल की आंतरिक संरचना से संबंधित नहीं हो सकते हैं (यानी, वे साधारण C / C ++ चर हैं)। इस मामले में, चर घोषित करते समय चर 'स्थानीय' का उपयोग किया जाना चाहिए। उदाहरण के लिए:

  local int i, total = 0; int recordCounts[5]; for( i = 0; i < 5; i++ ) total += recordCounts[i]; double records[ total ];

इस उदाहरण में, वैरिएबल I को टेम्प्लेट परिणाम पैनल में नहीं जोड़ा गया है, लेकिन, फिर भी, आप शो लोकल वेरिएबल्स कमांड (टेम्पलेट रिजल्ट्स पर राइट-क्लिक) का उपयोग करके स्थानीय चरों के प्रदर्शन को सक्षम कर सकते हैं।

परिवर्तनीय स्थिति

टेम्पलेट शुरू करने के बाद, सभी बनाए गए चर टेम्प्लेट परिणाम पैनल में पेड़ में प्रदर्शित किए जाते हैं। डिफ़ॉल्ट रूप से, सभी सरणियाँ और संरचनाएं "ढह गई" हैं और सूची में केवल '+' पर क्लिक करके "विस्तार" करने की क्षमता है; फिर भी, आपके द्वारा विस्तारित संरचना या सरणी तत्वों की पूरी सूची, इसके अलावा, कभी-कभी यह उपयोगी होता है, ताकि वे टेम्पलेट निष्पादित होने के तुरंत बाद टेम्पलेट परिणामों में इस तरह प्रदर्शित हों। ऐसा करने के लिए, आप चर पैरामीटर्स में '<open = true>' विशेषता का उपयोग कर सकते हैं, और विशेषता '<open = false>' का उपयोग कुछ संरचना या सरणी को न्यूनतम दिखाने के लिए भी किया जा सकता है (क्योंकि यह डिफ़ॉल्ट रूप से सेट है)।

पंक्तियां

शून्य-समाप्त स्ट्रिंग्स के साथ काम करने के लिए 010 संपादक के पास दो वाक्यविन्यास विकल्प हैं:

  char str[];

या

  string str;

जब तक यह हिट न हो जाए, दोनों लाइन को पढ़ना शामिल करते हैं। यूनिकोड स्ट्रिंग्स (लंबी लाइनों) में एन्कोडेड लाइनें का उपयोग करके पढ़ा जा सकता है:

  wchar_t str[];

या

  wstring str;

स्थानांतरण

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

छिपे हुए चर

विशेषता '<Hidden = true>' आपको टेम्पलेट परिणाम पैनल में चर के प्रदर्शन को छिपाने की अनुमति देता है, '<छिपा = गलत>' - रद्द करने के लिए।

II - संरचनाएं और संघ

संरचना

सी में, कीवर्ड 'संरचना' का उपयोग एक पदानुक्रमित डेटा संरचना को घोषित करने के लिए किया जाता है; 010 में, इसका बिल्कुल यही उद्देश्य है। उदाहरण के लिए, C / C ++ सिंटैक्स का उपयोग करके संरचनाएं घोषित की जाती हैं:

  struct myStruct { int a; int b; int c; };

यह कोड स्वचालित रूप से एक नया प्रकार myStruct बनाता है, अगला चरण इस प्रकार का एक चर (संरचना का एक उदाहरण) घोषित करना है:

  myStruct s;

टेम्प्लेट परिणामों में टाइप myStruct का एक चर घोषित करने के बाद, प्रवेश 'myStruct s' '+' चिह्न के साथ दिखाई देगा। '+' पर क्लिक करके, आप चर और उनके मूल्यों की ड्रॉप-डाउन सूची देख सकते हैं: a, b, c।

उदाहरणों को वैकल्पिक तरीके से भी घोषित किया जा सकता है:

  struct myStruct { int a; int b; int c; } s1, s2;

यह कोड myStruct के दो उदाहरण बना देगा, s1 के साथ फ़ाइल के पहले 12 बाइट्स पर कब्जा (प्रत्येक 4 बाइट्स के 3 पूर्णांक पूर्णांक मान), और अगले 12 बाइट्स s2।

ये संरचनाएं सी भाषा मानक की संरचनाओं की तुलना में अधिक "शक्तिशाली" हैं। 010 में, इस तरह के भावों का उपयोग जैसे कि, के लिए, जबकि समर्थित है। उदाहरण के लिए:

  struct myIfStruct { int a; if( a > 5 ) int b; else int c; } s;

इस उदाहरण में, संरचना एस का उदाहरण घोषित करने के बाद, केवल दो चर बनाए जाते हैं: ए या तो बी या सी। ध्यान दें कि पैटर्न को व्याख्या किए गए कोड के रूप में निष्पादित किया जाता है, ताकि सभी लाइनों को क्रमिक रूप से निष्पादित किया जाए। फ़ाइल से सीधे किसी का मान पढ़ा जाता है।

उदाहरण के लिए संरचनाएं भी नेस्टेड हो सकती हैं:

  struct { int width; struct COLOR { uchar r, g, b; } colors[width]; } line1;

संरचनाओं की घोषणा करने का एक वैकल्पिक तरीका टाइप्डिफ है। उदाहरण के लिए:

  typedef struct { ushort id; int size; } myData;

संघों

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

  union myUnion { ushort s; double d; int i; } u;

सभी तीन चर एक ही पते से शुरू किए जाएंगे और संघ का आकार 8 बाइट होगा, क्योंकि इसमें टाइप डबल का एक चर होता है।

तर्कों के साथ संरचनाएं और जुड़ना

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

  struct VarSizeStruct (int arraySize) { int id; int array[arraySize]; };

उदाहरण प्रस्तुत करते समय इस संरचना को घोषित करने के बाद, कोष्ठकों में संबंधित तर्कों को संलग्न करना आवश्यक है, उदाहरण के लिए:

  VarSizeStruct s1(5); VarSizeStruct s2(7);

तर्क का उपयोग संरचनाओं और यूनियनों में भी किया जा सकता है, जिन्हें टाइपराइफ घोषित किया गया है। उदाहरण के लिए:

  typedef struct (int arraySize) { int id; int array[arraySize]; } VarSizeStruct;

III - एरे, डुप्लिकेट, अनुकूलन

Arrays और डुप्लिकेट

010 संपादक में एक विशेष वाक्यविन्यास है जो आपको एक विशेष तरीके से एरे बनाने की अनुमति देता है। उसी नाम (डुप्लिकेट) के साथ घोषित चर का समर्थन किया जाता है, उदाहरण के लिए:

  int x; int y; int x;

010 संपादक में, एक ही नाम के साथ चर घोषित करना एक सरणी बनाने के बराबर है। इस उदाहरण में, x [0] का उपयोग x के पहले उपयोग के संदर्भ के रूप में किया जा सकता है, और x [1] को दूसरे के संदर्भ के रूप में। उदाहरण के लिए, साइकिल में डुप्लिकेट भी घोषित किए जा सकते हैं:

  local int i; for( i = 0; i < 5; i++ ) int x;

संरचनात्मक अनुकूलन

डिफ़ॉल्ट रूप से 010 संपादक अनुकूलन का समर्थन करता है, जो बड़ी संख्या में तत्वों (उदाहरण के लिए, एक मिलियन) के साथ संरचनाओं के सरणियों के साथ काम करना संभव बनाता है। अनुकूलन निम्नानुसार काम करता है: सरणी के पहले तत्व के आकार की गणना की जाती है, जिसके बाद यह माना जाता है कि अन्य सभी तत्व समान आकार होंगे। तदनुसार, चर आकार के तत्वों के मामले में, परिणाम गलत होगा। ऑप्टिमाइज़ेशन को बंद करने के लिए, '<ऑप्टिमाइज़ = गलत>' विशेषता का उपयोग करें। उदाहरण के लिए:

  typedef struct { int id; int length; uchar data[ length ]; } RECORD; RECORD record[5] <optimize=false>;

यदि आउटपुट फ़ील्ड में 010 संपादक एक चेतावनी प्रदर्शित करता है, लेकिन आप अभी भी ऑप्टिमाइज़ेशन का उपयोग करना चाहते हैं, तो इसके उपयोग को '<ऑप्टिमाइज़ = ट्रू>' के साथ सक्षम करें, चेतावनी छिपाई जाएगी। टाइपिडिफ के माध्यम से घोषित नहीं किए गए संरचनाओं के लिए विशेषता '<ऑप्टिमेट = गलत>' का भी उपयोग किया जा सकता है।

IV - बिट संरचनाएं

संरचनाओं में फ़ील्ड को बिट्स के समूहों में विभाजित किया जा सकता है, यह सुविधा आपको एक मेमोरी ब्लॉक में कई चर स्टोर करने की अनुमति देती है। थोड़ा क्षेत्र घोषित करने का वाक्य विन्यास है:

 _ <_> : _

प्रकार चार, छोटा, इंट, इंट 64 (अहस्ताक्षरित या हस्ताक्षरित) या कोई अन्य समकक्ष प्रकार हो सकता है। यदि कुछ चर का नाम निर्दिष्ट नहीं है, तो इसे छोड़ दिया जाएगा। उदाहरण के लिए:

  int alpha : 5; int : 12; int beta : 15;

इस प्रकार, एक चार बाइट फ़ील्ड (32 बिट्स) में दो चर होंगे: अल्फा और बीटा, पहला 5 बिट्स लेता है, दूसरा 15 बिट्स लेता है, जबकि चर के बीच 12 बिट्स को छोड़ दिया जाता है।

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

  enum <ushort> ENUM1 { VAL1_1=25, VAL1_2=29, VAL1_3=7 } var1 : 12; enum <ushort> ENUM2 { VAL2_1=5, VAL2_2=6 } var2 : 4;

V - कस्टम चर

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

किसी चर को पढ़ने और लिखने के कार्य को असाइन करने के लिए, क्रमशः '<read = <function name >>> और <write = <function name >> "विशेषता का उपयोग करें। रीड फ़ंक्शन एक चर को एक तर्क के रूप में लेता है और एक स्ट्रिंग लौटाता है, लेखन फ़ंक्शन एक तर्क को एक चर के लिए एक संकेतक के रूप में लेता है और एक स्ट्रिंग प्रतिनिधित्व में इसका मूल्य। उदाहरण के लिए, 16 बिट्स (8 सबसे महत्वपूर्ण बिट्स पूर्णांक भाग का निर्धारण करते हैं, और 8 सबसे महत्वपूर्ण अंशों का निर्धारण करते हैं) का उपयोग करके "आंशिक" प्रकार निर्धारित करने के लिए, आप फ़ंक्शन का उपयोग कर सकते हैं:

  typedef ushort FIXEDPT <read=FIXEDPTRead, write=FIXEDPTWrite>; string FIXEDPTRead( FIXEDPT f ) { string s; SPrintf( s, "%lg", f / 256.0 ); return s; } void FIXEDPTWrite( FIXEDPT &f, string s ) { f = (FIXEDPT)( Atof( s ) * 256 ); }

इस उदाहरण में, FIXEDPT चर को रिकॉर्ड विशेषता के बिना परिभाषित किया जा सकता है, लेकिन इस मामले में यह केवल-पढ़ने के लिए होगा।

टेम्प्लेट परिणाम पैनल में सरणियाँ प्रदर्शित करते समय, आमतौर पर कोई मान प्रदर्शित नहीं होता है जब तक कि सरणी "विस्तारित" न हो। संपूर्ण सरणी पर तुरंत एक निश्चित मान निर्धारित करने के लिए, आप एक मनमाना चर का उपयोग कर सकते हैं, कार्यों को पढ़ और लिख सकते हैं। उदाहरण के लिए:

  typedef float VEC3F[3] <read=Vec3FRead, write=Vec3FWrite>; string Vec3FRead( VEC3F v ) { string s; SPrintf( s, "(%f %f %f)", v[0], v[1], v[2] ); return s; } void Vec3FWrite( VEC3F &v, string s ) { SScanf( s, "(%f %f %f)", v[0], v[1], v[2] ); }

जानें कि अब पढ़ने और लिखने के कार्यों को किसी सरणी या प्रत्येक तत्व के व्यक्तिगत तत्वों के लिए परिभाषित नहीं किया जा सकता है।

VI - ऑन-डिमांड संरचनाएं

टेम्प्लेट में बड़ी संख्या में चर को परिभाषित किया जा सकता है, जो सिस्टम मेमोरी के दृष्टिकोण से बहुत महंगा है। इस बारीकियों को ध्यान में रखने के लिए, आप ऑन-डिमांड संरचनाओं का उपयोग कर सकते हैं। इस मामले में, संरचना या एसोसिएशन के भीतर चर तब तक जांच के तहत फाइल में "हस्तांतरित" नहीं किए जाते हैं जब तक कि यह आवश्यक न हो (उदाहरण के लिए, जब तक कि ढांचे का विस्तार खाका रिज़ल्ट्स पैनल में न हो जाए)। ऑन-डिमांड संरचनाओं या संघों का उपयोग करने के लिए, आपको मैन्युअल रूप से उनके आकार को पहले से निर्दिष्ट करना होगा: '<size =' | ऐसी संरचनाओं और संघों का आकार हमेशा तय होता है। उदाहरण के लिए:

  typedef struct { int header; int value1; int value2; } MyStruct <size=12>;

इस स्थिति में, MyStruct संरचना (शीर्ष लेख, मान 1 और मान 2) की सामग्री को तब तक निर्धारित नहीं किया जाता है जब तक कि इसकी आवश्यकता न हो।

सप्तम - मर्यादा

टेम्पलेट्स 010 संपादक, एएनएसआई सी के साथ कई समानताएं होने के बावजूद, कई महत्वपूर्ण अंतर हैं और पूरी तरह से संगत नहीं हैं। ANSI C और 010 संपादक टेम्प्लेट के बीच महत्वपूर्ण अंतरों की एक सूची:

संकेत

वर्तमान में, '*' पॉइंटर्स का उपयोग समर्थित नहीं है। फ़ंक्शन तर्कों के लिए केवल 'और' संदर्भों का समर्थन किया जाता है।

दिशा निर्देशों

अधिकांश प्रीप्रोसेसर निर्देशों का समर्थन किया जाता है, जिसमें #define, #ifdef, #ifndef, आदि शामिल हैं। हालांकि, #if निर्देश वर्तमान में समर्थित नहीं है, और न ही #define निर्देश का उपयोग करते हुए मैक्रो की घोषणा की गई है।

बहुआयामी Arrays

वर्तमान में बहुआयामी सरणियों का समर्थन नहीं किया जाता है, लेकिन उनका उपयोग करने का एक वैकल्पिक तरीका है। उदाहरण के लिए, 'फ्लोट मैट्रिक्स [4] [4]' को परिभाषित करने के बजाय उसी सरणी को परिभाषित किया जा सकता है:

  typedef struct { float row[4]; } MATRIX[4]; MATRIX m;

नियंत्रण स्थानांतरण

गोटो समर्थित नहीं है।

यदि आपके पास प्रश्न हैं, तो पूछें, जवाब देने के लिए हमेशा तैयार रहें।
अनुवाद में मामूली अशुद्धियाँ हो सकती हैं, अगर आपको कुछ मिलता है, तो पीएम को लिखें, मैं इसे सही करूंगा।
सादर, डागरोन ।

यह भी देखें:

हेक्स संपादक संदर्भ सामग्री 010 संपादक: टेम्पलेट्स