C प्रोग्रामिंग लैंग्वेज मानकों के अनुसार किसी स्ट्रक्चर को इनिशियलाइज़ कैसे करें

Question

मैं एक संरचना तत्व को इनिशियलाइज़ करना चाहता हूँ, डिक्लेरेशन और इनिशियलाइज़ेशन में विभाजन। यह वही है जो मेरे पास है:

typedef struct MY_TYPE {
  bool flag;
  short int value;
  double stuff;
} MY_TYPE;

void function(void) {
  MY_TYPE a;
  ...
  a = { true, 15, 0.123 }
}

क्या यह MY_TYPEसी प्रोग्रामिंग भाषा मानकों (C89, C90, C99, C11, आदि) के अनुसार स्थानीय चर घोषित करने और शुरू करने का तरीका है ? या कुछ बेहतर है या कम से कम काम कर रहा है?

अपडेट मैं एक स्थिर इनिशियलाइज़ेशन तत्व के साथ समाप्त हुआ, जहाँ मैंने अपनी आवश्यकताओं के अनुसार हर सबलेमेंट सेट किया।

Comments

आपको वास्तव में एक बेहतर उत्तर को स्वीकार करना चाहिए, मैं देख रहा हूं कि आपको कुछ खराब कोडिंग गाइड का उपयोग करना था, लेकिन आपको अभी भी अन्य लोगों को यह सुझाव नहीं देना चाहिए कि ऐसा करने का सही तरीका है ..

— Karoly Horvath

@KarolyHorvath अच्छी तरह से, अधिकांश अच्छे उत्तर C99 के लिए विशिष्ट हैं। हो सकता है कि मेरा सवाल stackoverflow.com/questions/6624975/… का डुप्लिकेट हो ?

— चापलूसी

यदि वह आपका मूल इरादा था, तो शायद हाँ, लेकिन फिर 1) वोट बहुत भ्रामक होंगे। 2) शीर्ष खोज हिट से यह केवल वही है जो C99 रास्ता दिखाता है ..... इस पृष्ठ को C99 प्रदर्शन के लिए फिर से उपयोग करना बेहतर होगा ... (जाहिर है लोगों ने इस पृष्ठ को लिंक करने के लिए यह दिखाना शुरू किया कि कैसे करते हैं)

— कारोली होर्वाथ

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

— कीथ थॉम्पसन

कड़ाई से बोलते हुए, शब्द "एएनएसआई सी" अब 2011 आईएसओ मानक को संदर्भित करता है, जिसे एएनएसआई ने अपनाया है। लेकिन व्यवहार में "एएनएसआई सी" शब्द आमतौर पर (आधिकारिक तौर पर अप्रचलित) 1989 मानक को संदर्भित करता है। उदाहरण के लिए, "gcc -ansi" अभी भी 1989 के मानक को लागू करता है। चूंकि यह आईएसओ है जो 1990, 1999 और 2011 मानकों को प्रकाशित करता है, इसलिए "एएनएसआई सी" शब्द से बचने के लिए सबसे अच्छा है, और अगर भ्रम की संभावना है तो मानक की तारीख को देखें।

— कीथ थॉम्पसन

Answer 1

(ANSI) C99 में, आप किसी संरचना को शुरू करने के लिए नामित इनिशियलाइज़र का उपयोग कर सकते हैं :

MY_TYPE a = { .flag = true, .value = 123, .stuff = 0.456 };

संपादित करें: अन्य सदस्यों को शून्य के रूप में आरंभीकृत किया जाता है: "क्षेत्र के सदस्यों को अंतर्निहित रूप से वैसा ही आरंभिक किया जाता है, जिसमें स्थिर भंडारण अवधि होती है।" ( https://gcc.gnu.org/onbuildocs/gcc/Designated-Inits.html )

Comments

बहुत अच्छे धन्यवाद। आप उन्हें घोंसला भी बना सकते हैं: स्थिर ऑक्सरे 2f किरण = {.unitDir = {.x = 1.0f, .y = 0.0f}};

— ओरियन एल्जेनिल

इस सवाल का जवाब बिल्कुल नहीं है। ओपी घोषणा से आरंभ को अलग करना चाहता है।

— ऑसविन

C99! = ANSI C - तो यह C89 में काम नहीं करता है, न ही C90 में।

— टिम वाईमन

C99 है एएनएसआई सी, देखना यह

— Cutberto ओकाम्पो

@CutbertoOcampo मैं समझता हूं कि अब क्या हुआ। मूल प्रश्न ANSI C में समाधान के लिए पूछ रहा था, जाहिर है वह केवल C89 के लिए उत्तर चाहता था। 2016 में प्रश्न को संपादित किया गया और "एएनएसआई सी" को हटा दिया गया, जिससे अब यह समझना मुश्किल है कि यह उत्तर और टिप्पणियों का उल्लेख क्यों है (एएनएसआई) सी 99 "।

— .tienne

Answer 2

आप इसे एक यौगिक शाब्दिक के साथ कर सकते हैं । उस पृष्ठ के अनुसार, यह C99 में काम करता है (जो ANSI C के रूप में भी गिना जाता है )।

MY_TYPE a;

a = (MY_TYPE) { .flag = true, .value = 123, .stuff = 0.456 };
...
a = (MY_TYPE) { .value = 234, .stuff = 1.234, .flag = false };

शुरुआती में पदनाम वैकल्पिक हैं; आप भी लिख सकते हैं:

a = (MY_TYPE) { true,  123, 0.456 };
...
a = (MY_TYPE) { false, 234, 1.234 };

Comments

इसलिए, निर्दिष्ट इनिशियलाइज़र उसी समय के लिए हैं जब आप एक ही समय में घोषणा करते हैं और परिभाषित करते हैं, लेकिन कंपाउंड शाब्दिक तब होते हैं जब आप पहले से घोषित चर को परिभाषित करते हैं?

— गेरिमिया

@Geremia आपको पहले दोनों मामलों में संरचना को परिभाषित करना होगा, लेकिन निर्दिष्ट शुरुआती के साथ, आप कोड को अधिक पठनीय बनाते हैं, और संरचना में परिवर्तन के मामले में त्रुटियों के प्रति अधिक लचीला होते हैं।

— होइजुई

यह थोड़ा मुश्किल है। कई बार (कुछ सफल) मैंने नामित शुरुआती का उपयोग करने की कोशिश की है। हालांकि, यह अब केवल स्पष्ट हो गया है (आपके और @ दार्शनिक उदाहरण के लिए धन्यवाद) कि यदि ऑब्जेक्ट निर्माण के समय इनिशलाइज़र का उपयोग नहीं किया जाता है, तो एक कास्ट मौजूद होना चाहिए। हालाँकि, मैंने अब यह भी जान लिया है कि यदि इनिशियलाइज़र का उपयोग ऑब्जेक्ट क्रिएशन (आपके उदाहरण में) के अलावा किसी अन्य समय में किया जाता है, तो इसे कंपाउंड शाब्दिक के रूप में संदर्भित किया जाता है , न कि कड़ाई से निर्दिष्ट इनिशियलाइज़र के रूप में । ideone.com/Ze3rnZ

— sherrellbc

Answer 3

मैं देखता हूं कि आपको एएनएसआई सी 99 के बारे में पहले ही जवाब मिल गया है, इसलिए मैं एएनएसआई सी 89 के बारे में एक हड्डी फेंक दूंगा। एएनएसआई सी 89 आपको इस तरह से एक संरचना को शुरू करने की अनुमति देता है:

typedef struct Item {
    int a;
    float b;
    char* name;
} Item;

int main(void) {
    Item item = { 5, 2.2, "George" };
    return 0;
}

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

यदि आप अपनी संरचना में मूल्यों को आरंभ नहीं करते हैं, तो सभी चर में "कचरा मूल्य" होंगे।

सौभाग्य!

Comments

क्या आरंभीकरण में चर का उपयोग करना संभव है?

— सियान

@ यह स्वचालित भंडारण अवधि वाली वस्तुओं के लिए है। देखें 6.7.9 13) खुले में-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf । वैश्विक वस्तुओं के लिए शाब्दिक रूप से बहुत सीमित है। आप अन्य वैश्विक वस्तुओं का उपयोग भी नहीं कर सकते, भले ही वे कब्ज हों।

— PSkocik

तो सी 99 के साथ एकमात्र अंतर यह है कि आप पदनाम निर्दिष्ट नहीं कर सकते हैं?

— एकैस्टीफे

Answer 4

a = (MYTYPE){ true, 15, 0.123 };

C99 में ठीक करेगा

Comments

मुझे ईमानदारी से लगता है कि उत्तर सबसे उपयोगी है, लेकिन जो भी हो।

— user12211554

Answer 5

आप लगभग मिल चुके हैं ...

MY_TYPE a = { true,15,0.123 };

'स्ट्रक्चर इनिशियलाइज़ c' पर त्वरित खोज मुझे यह दिखाती है

Comments

मुझे लगता है कि यह मानक C के लिए सही है, लेकिन ANSI C (99?) के लिए नहीं। इसके अलावा, मैं उन नियमों को कोडित करने के लिए बाध्य हूं जो मुझे एक ही बार में घोषणा और प्रारंभ करने की अनुमति नहीं देंगे, इसलिए मुझे इसे विभाजित करना होगा और हर एक सबलेमेंट को इनिशियलाइज़ करना होगा।

— चापलूसी

प्रारंभ केवल घोषणा के बिंदु पर हो सकता है। यही इसका अर्थ है 'आरंभ'। अन्यथा आप एक अपरिभाषित मान को अपने चर / संरचना के इनबिल्ट मान की अनुमति दे रहे हैं, और फिर बाद में एक मान निर्दिष्ट कर रहे हैं।

— केवली

उम ... आपके पास कोडिंग नियम हैं जो जानबूझकर खराब हैं? शायद आपको उस आदमी का परिचय कराना चाहिए जिसने उन्हें "रिसोर्स एक्विजिशन इज़ इनिशियलाइज़ेशन" ( en.wikipedia.org/wiki/RAII )

— जेम्स करन डे

मेरा विश्वास करो, मैं वास्तव में, वास्तव में, इस बिंदु पर इस नियम का एक सा नहीं बदल सकता। इसे कोड करना भयानक लगता है। और 70 के दशक के ठीक बाहर बहुत सारे अन्य नियम हैं, जैसे कि संशोधन संख्या जैसे प्रबंधन जानकारी के साथ स्थिर कोड हेडर। हर रिलीज के लिए बदलाव, भले ही स्रोत बदल न जाए ...

— cringe

Answer 6

C प्रोग्रामिंग लैंग्वेज स्टैंडर्ड ISO / IEC 9899: 1999 (आमतौर पर C99 के रूप में जाना जाता है) किसी को संरचना या संघ के सदस्यों को इनिशियलाइज़ करने के लिए नामित इनिशियलाइज़र का उपयोग करने की अनुमति देता है:

MY_TYPE a = { .stuff = 0.456, .flag = true, .value = 123 };

यह में परिभाषित किया गया है paragraph 7, खंड 6.7.8 Initialization1999 मानक के रूप में: आईएसओ / आईईसी 9899 की:

यदि एक डिज़ाइनर के पास फॉर्म है
। पहचानकर्ता
तब वर्तमान वस्तु (नीचे परिभाषित) में संरचना या संघ प्रकार होगा और पहचानकर्ता उस प्रकार के सदस्य का नाम होगा।

ध्यान दें कि paragraph 9समान अनुभाग बताता है कि:

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

जीएनयू जीसीसी कार्यान्वयन में हालांकि छोड़े गए सदस्यों को शून्य या शून्य जैसे टाइप-उचित मूल्य के रूप में आरंभ किया जाता है। में खंड कहा गया है 6.27 मनोनीत initializers जीएनयू जीसीसी दस्तावेज की:

क्षेत्र के सदस्यों को अनुमानित रूप से वैसा ही इनिशियलाइज़ किया जाता है, जिसमें स्थिर भंडारण अवधि होती है।

Microsoft Visual C ++ कंपाइलर को आधिकारिक ब्लॉग पोस्ट C ++ अनुरूपता रोडमैप के अनुसार 2013 के बाद से निर्दिष्ट इनिशियलाइज़र का समर्थन करना चाहिए । MSDN विज़ुअल स्टूडियो प्रलेखन Initializing unions and structsमें इनिशियलाइज़र्स लेख के पैराग्राफ से पता चलता है कि अनाम सदस्य जीएनयू जीसीसी के समान शून्य-उचित मूल्यों के लिए प्रारंभिक हैं।

आईएसओ / आईईसी 9899: 2011 मानक (आमतौर पर सी 11 के रूप में जाना जाता है) जिसने आईएसओ / आईईसी 9899 को पार कर लिया था: 1999 अनुभाग के तहत नामित शुरुआती को बरकरार रखता है 6.7.9 Initialization। यह paragraph 9अपरिवर्तित भी बनाए रखता है ।

नई ISO / IEC 9899: 2018 मानक (आमतौर पर C18 के रूप में जाना जाता है) जिसने ISO / IEC 9899 को छोड़ दिया था: 2011 ने अनुभाग के तहत नामित शुरुआती को बरकरार रखा 6.7.9 Initialization। यह paragraph 9अपरिवर्तित भी बनाए रखता है ।

Comments

प्रारंभ में मैंने इसे स्वीकृत उत्तर के रूप में संपादित करने का सुझाव दिया था, लेकिन इसे अस्वीकार कर दिया गया था। इस प्रकार मैं इसे उत्तर के रूप में पोस्ट करता हूं।

— PF4Public

मेरा मानना ​​है कि "सदस्य" का अर्थ "छोड़े गए क्षेत्र" नहीं है, बल्कि "अनाम सदस्य" जैसे संघ में हैं struct thing { union { char ch; int i; }; };। मानक बाद में कहता है: "अगर किसी ब्रेस-एनक्लोज्ड लिस्ट में कम इनिशियलाइज़र होते हैं, तो एग्रीगेट के तत्व या सदस्य होते हैं, या किसी स्ट्रिंग स्ट्रिंगल में कम कैरेक्टर ज्ञात आकार की एक ऐरिअली को इनिशियलाइज़ करने के लिए इस्तेमाल होते हैं, जहाँ ऐरे में एलीमेंट होते हैं," कुल का शेष प्रारंभिक रूप से वैसा ही होगा जैसा कि स्थिर भंडारण अवधि वाली वस्तुओं के रूप में होता है। "

— प्रकट होना

Answer 7

जैसा कि रॉन नूनी ने कहा:

typedef struct Item {
    int a;
    float b;
    char* name;
} Item;

int main(void) {
    Item item = {5, 2.2, "George"};
    return 0;
}

याद रखने के लिए एक महत्वपूर्ण बात: फिलहाल आप संरचना में एक भी वस्तु / चर को इनिशियलाइज़ करते हैं, इसके सभी अन्य चर डिफ़ॉल्ट मान पर आरंभीकृत होंगे।

यदि आप अपनी संरचना में मूल्यों को इनिशियलाइज़ नहीं करते हैं (अर्थात यदि आप केवल उस वेरिएबल को घोषित करते हैं), तो सभी variable.membersमें "कचरा मूल्य" होंगे, केवल तभी जब घोषणा स्थानीय हो!

यदि घोषणा वैश्विक या स्थिर है (जैसे कि इस मामले में), तो सभी असंवैधानिक variable.membersको स्वचालित रूप से आरंभ किया जाएगा:

• 0 पूर्णांक और फ्लोटिंग बिंदु के लिए
• '\0'के लिए charनिश्चित रूप से यह बस के रूप में ही है 0, और charएक पूर्णांक प्रकार है)
• NULL संकेत के लिए।

Comments

स्थानीय / वैश्विक के बारे में दिलचस्प, यह संरचना tm समय मूल्यों पर भी लागू होता है। मेरे पास एक स्थानीय एक था और एक मामले में डीएसटी था, दूसरे में ऐसा नहीं था, क्योंकि मैंने कुछ भी नहीं किया था। मैं DST (tm_isdst फ़ील्ड) का उपयोग नहीं कर रहा था, यह स्ट्रैप्टम से था, लेकिन जब मैंने time_t में परिवर्तित किया तो कुछ एक घंटे के बंद थे।

— एलन कोरी

Answer 8

void function(void) {
  MY_TYPE a;
  a.flag = true;
  a.value = 15;
  a.stuff = 0.123;
}

Comments

एक बार मैंने सुना है कि 'आरंभीकरण असाइनमेंट से अलग है'। तो क्या यह आरंभीकरण के बजाय एक काम नहीं है?

— हायरी यूउर कोल्टुक

Answer 9

यदि MS ने C99 में अपडेट नहीं किया है, तो MY_TYPE a = {true, 15,0.123};

Answer 10

मुझे स्ट्रक्चर्स को इनिशियलाइज़ करने का एक और तरीका मिला।

संरचना:

typedef struct test {
    int num;
    char* str;
} test;

प्रारंभ:

test tt = {
    num: 42,
    str: "nice"
};

जीसीसी के प्रलेखन के अनुसार, यह सिंटैक्स जीसीसी 2.5 के बाद से अप्रचलित है ।

Answer 11

मुझे इनमें से कोई भी जवाब पसंद नहीं आया इसलिए मैंने अपना बना लिया। मुझे नहीं पता कि यह एएनएसआई सी है या नहीं, यह डिफ़ॉल्ट मोड में सिर्फ जीसीसी 4.2.1 है। मैं कभी भी ब्रैकेटिंग को याद नहीं रख सकता, इसलिए मैं अपने डेटा के सबसेट के साथ शुरू करता हूं और कंपाइलर एरर मैसेज के साथ लड़ाई करता हूं, जब तक कि वह बन्द नहीं हो जाता। पठनीयता मेरी पहली प्राथमिकता है।

    // in a header:
    typedef unsigned char uchar;

    struct fields {
      uchar num;
      uchar lbl[35];
    };

    // in an actual c file (I have 2 in this case)
    struct fields labels[] = {
      {0,"Package"},
      {1,"Version"},
      {2,"Apport"},
      {3,"Architecture"},
      {4,"Bugs"},
      {5,"Description-md5"},
      {6,"Essential"},
      {7,"Filename"},
      {8,"Ghc-Package"},
      {9,"Gstreamer-Version"},
      {10,"Homepage"},
      {11,"Installed-Size"},
      {12,"MD5sum"},
      {13,"Maintainer"},
      {14,"Modaliases"},
      {15,"Multi-Arch"},
      {16,"Npp-Description"},
      {17,"Npp-File"},
      {18,"Npp-Name"},
      {19,"Origin"}
    };

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

Comments

संरचनाओं की सरणी के आरंभीकरण के बारे में कोई सवाल नहीं था! मेरा मतलब है, आपके उत्तर में ओवरहेड है।

— विक्टर सिग्नेवेस्की

मुझे लगता है कि मेरी बात पहले से ही प्रत्येक मूल्य को निर्धारित करने के लिए = का उपयोग करते हुए मूल्यों के साथ संरचना की घोषणा कर रही थी।

— एलन कोरी

यह सिद्धांत लागू होता है चाहे वह एक संरचना हो या उनमें से एक सरणी। का उपयोग करना = वास्तव में आरंभीकरण नहीं है, मुझे नहीं लगता।

— एलन कोरी

Answer 12

सी में संरचना इस तरह घोषित की जा सकती है और आरंभ की जा सकती है:

typedef struct book
{
    char title[10];
    char author[10];
    float price;
} book;

int main() {
    book b1={"DS", "Ajay", 250.0};

    printf("%s \t %s \t %f", b1.title, b1.author, b1.price);

    return 0;
}

Answer 13

मैंने पढ़ा है माइक्रोसॉफ्ट विजुअल स्टूडियो 2015 डॉक्यूमेंटेशन फॉर इनिशियलाइज़िंग एग्रीगेट टाइप्स के बारे में अभी तक है, जिसमें सभी तरह के इनिशियलाइज़ेशन हैं{...} , लेकिन इसके वहाँ समझाया गया है, लेकिन डॉट के साथ इनिशियलाइज़िंग का नाम 'डिज़ाइनर' नहीं है। यह भी काम नहीं करता है।

C99 मानक अध्याय 6.7.8 इनिशियलाइज़ेशन डिज़ाइनर की संभावना की व्याख्या करता है, लेकिन मेरे दिमाग में यह वास्तव में जटिल संरचनाओं के लिए स्पष्ट नहीं है। पीडीएफ के रूप में C99 मानक ।

मेरे दिमाग में, यह बेहतर हो सकता है

1. उपयोग = {0};सभी स्थैतिक डेटा के लिए -initialization का । यह मशीन कोड के लिए कम प्रयास है।

2. उदाहरण के लिए, मैक्रोज़ का उपयोग करें

   typedef MyStruct_t{ int x, int a, int b; } MyStruct; define INIT_MyStruct(A,B) { 0, A, B}

मैक्रो को अनुकूलित किया जा सकता है, इसकी तर्क सूची परिवर्तित संरचना सामग्री से स्वतंत्र हो सकती है। यह उचित है अगर कम तत्वों को आरंभीकृत किया जाना चाहिए। यह नेस्टेड संरचना के लिए भी उचित है। 3. एक सरल रूप है: एक सबरूटीन में प्रारंभिक:

void init_MyStruct(MyStruct* thiz, int a, int b) {
  thiz->a = a; thiz->b = b; }

यह दिनचर्या सी में ObjectOriented की तरह दिखाई देता है। C ++ के साथ भी इसे संकलित करने के लिए thizनहीं this!

MyStruct data = {0}; //all is zero!
init_MyStruct(&data, 3, 456);

Answer 14

मैं अपनी संरचना को इनिशियलाइज़ करने के लिए एक अच्छा तरीका ढूंढ रहा हूँ, और मैं नीचे (C99) का उपयोग करने के लिए तैयार हो गया हूँ। यह मुझे या तो एक ही संरचना या समान प्रकार की संरचनाओं की एक सरणी को आरंभिक प्रकारों के रूप में आरंभ करने देता है।

typedef struct {
    char *str;
    size_t len;
    jsmntok_t *tok;
    int tsz;
} jsmn_ts;

#define jsmn_ts_default (jsmn_ts){NULL, 0, NULL, 0}

इसका उपयोग कोड में किया जा सकता है:

jsmn_ts mydata = jsmn_ts_default; /* initialization of a single struct */

jsmn_ts myarray[10] = {jsmn_ts_default, jsmn_ts_default}; /* initialization of
                                                    first 2 structs in the array */

Comments

लेकिन यह डिफ़ॉल्ट मानों के लिए संरचनाओं की एक सरणी को इनिशियलाइज़ नहीं करता है। यह सरणी में पहली संरचना को दिए गए मानों पर jsmn_ts_defaultआरंभीकृत करता है, लेकिन बाकी संरचनाएं आरंभीकृत होती हैं जैसे कि सरणी में स्थैतिक भंडारण अवधि होती है, जिसका अर्थ है कि सदस्यों को प्रारंभिक NULLऔर 0। लेकिन अगर आप बदलते हैं तो आप #define jsmn_ts_default (jsmn_ts){"default", sizeof "default", NULL, 0}देखेंगे कि केवल पहला एरे तत्व ही आरंभिक हो जाता है।

— पूर्व निहिलो

हां, मैं अभी और परीक्षण से वापस आया था, पोस्ट को संपादित करना चाहता था :) btw, एक ही व्यवहार होता है int a[10] = {1};केवल 1 तत्व के साथ होगा==1

— div0man