C में संरचना सदस्य के लिए डिफ़ॉल्ट मान

Question 1

क्या कुछ संरचना सदस्य के लिए डिफ़ॉल्ट मान सेट करना संभव है? मैंने निम्नलिखित कोशिश की लेकिन, यह सिंटैक्स त्रुटि का कारण होगा:

typedef struct
{
  int flag = 3;
} MyStruct;

त्रुटियाँ:

$ gcc -o testIt test.c 
test.c:7: error: expected ‘:’, ‘,’, ‘;’, ‘}’ or ‘__attribute__’ before ‘=’ token
test.c: In function ‘main’:
test.c:17: error: ‘struct <anonymous>’ has no member named ‘flag’

Question 2

संरचना एक डेटा प्रकार है । आप डेटा प्रकार को मान नहीं देते हैं। आप डेटा प्रकारों के उदाहरणों / वस्तुओं को मान देते हैं।
तो नहीं यह सी में संभव नहीं है।

इसके बजाय आप एक फ़ंक्शन लिख सकते हैं जो संरचना उदाहरण के लिए प्रारंभ करता है।

वैकल्पिक रूप से, आप कर सकते हैं:

struct MyStruct_s 
{
    int id;
} MyStruct_default = {3};

typedef struct MyStruct_s MyStruct;

और फिर हमेशा के रूप में अपने नए उदाहरण शुरू:

MyStruct mInstance = MyStruct_default;

Question 3

आप इसे इस तरह से नहीं कर सकते

इसके बजाय निम्नलिखित का उपयोग करें

typedef struct
{
   int id;
   char* name;
}employee;

employee emp = {
.id = 0, 
.name = "none"
};

आप अपने उदाहरणों को परिभाषित करने और आरंभ करने के लिए मैक्रो का उपयोग कर सकते हैं । इससे आप हर बार नए उदाहरण को परिभाषित करना चाहते हैं और इसे आरंभ कर सकते हैं।

typedef struct
{
   int id;
   char* name;
}employee;

#define INIT_EMPLOYEE(X) employee X = {.id = 0, .name ="none"}

और अपने कोड में जब आपको कर्मचारी प्रकार के साथ नए उदाहरण को परिभाषित करने की आवश्यकता होती है, तो आप इस मैक्रो को कॉल करते हैं जैसे:

INIT_EMPLOYEE(emp);

Question 4

मैं एल्स से सहमत हूं कि आप सी में संरचना को परिभाषित करने के समय पर प्रारंभ नहीं कर सकते हैं। लेकिन आप नीचे दिखाए गए उदाहरणों को बनाने के समय संरचना को आरंभीकृत कर सकते हैं।

सी में,

 struct s {
        int i;
        int j;
    };

    struct s s_instance = { 10 ,20 };

C ++ में नीचे दी गई संरचना की परिभाषा में प्रत्यक्ष मूल्य देना संभव है

struct s {
    int i;

    s(): i(10)
    {
    }
};

Question 5

तुम कर सकते हो:

struct employee_s {
  int id;
  char* name;
} employee_default = {0, "none"};

typedef struct employee_s employee;

और फिर आपको बस एक नया कर्मचारी चर घोषित करते समय डिफ़ॉल्ट आरंभीकरण करना याद रखना होगा:

employee foo = employee_default;

वैकल्पिक रूप से, आप हमेशा फ़ैक्टरी फ़ंक्शन के माध्यम से अपने कर्मचारी संरचना का निर्माण कर सकते हैं।

Question 6

यदि आप उपयोग कर रहे हैं तो आप ऑब्जेक्ट निर्माण में gccदे सकते हैं designated initializers।

typedef struct
{
   int id=0;
   char* name="none";
}employee;

employee e = 
{
 .id = 0;
 .name = "none";
};

या, बस सरणी आरंभीकरण की तरह उपयोग करें।

employee e = {0 , "none"};

Question 7

एक डिफ़ॉल्ट संरचना बनाएं जैसा कि अन्य उत्तरों में उल्लेख किया गया है:

struct MyStruct
{
    int flag;
}

MyStruct_default = {3};

हालाँकि, उपरोक्त कोड हेडर फ़ाइल में काम नहीं करेगा - आपको त्रुटि मिलेगी multiple definition of 'MyStruct_default':। इस समस्या को हल करने के लिए, externहेडर फ़ाइल में इसके बजाय का उपयोग करें :

struct MyStruct
{
    int flag;
};

extern const struct MyStruct MyStruct_default;

और cफाइल में:

const struct MyStruct MyStruct_default = {3};

आशा है कि यह हेडर फ़ाइल में किसी को भी परेशानी होने में मदद करता है।

Question 8

इससे भी अधिक, मौजूदा उत्तरों को जोड़ने के लिए, आप एक मैक्रो का उपयोग कर सकते हैं जो एक संरचना आरम्भक को छुपाता है:

#define DEFAULT_EMPLOYEE { 0, "none" }

फिर अपने कोड में:

employee john = DEFAULT_EMPLOYEE;

Question 9

आप एक आरंभिक कार्य को कार्यान्वित कर सकते हैं:

employee init_employee() {
  empolyee const e = {0,"none"};
  return e;
}

Question 10

आप संरचना को आरंभ करने के लिए कुछ फ़ंक्शन का उपयोग कर सकते हैं,

typedef struct
{
    int flag;
} MyStruct;

MyStruct GetMyStruct(int value)
{
    MyStruct My = {0};
    My.flag = value;
    return My;
}

void main (void)
{
    MyStruct temp;
    temp = GetMyStruct(3);
    printf("%d\n", temp.flag);
}

संपादित करें:

typedef struct
{
    int flag;
} MyStruct;

MyStruct MyData[20];

MyStruct GetMyStruct(int value)
{
    MyStruct My = {0};
    My.flag = value;
    return My;
}

void main (void)
{
    int i;
    for (i = 0; i < 20; i ++)
        MyData[i] = GetMyStruct(3);

    for (i = 0; i < 20; i ++)
        printf("%d\n", MyData[i].flag);
}

Question 11

आप var सुविधा के साथ C प्रीप्रोसेसर कार्यों के संयोजन का उपयोग कर सकते हैं , यौगिक शाब्दिक और अधिकतम सुविधा के लिए निर्दिष्ट इनिशियलाइज़र :

typedef struct {
    int id;
    char* name;
} employee;

#define EMPLOYEE(...) ((employee) { .id = 0, .name = "none", ##__VA_ARGS__ })

employee john = EMPLOYEE(.name="John");  // no id initialization
employee jane = EMPLOYEE(.id=5);         // no name initialization

Question 12

यदि आप केवल एक बार के लिए इस संरचना का उपयोग करते हैं , अर्थात एक वैश्विक / स्थिर वैरिएबल बनाते हैं, तो आप typedefइस वैरिएबल को तुरंत हटा सकते हैं और आरंभिक कर सकते हैं:

struct {
    int id;
    char *name;
} employee = {
    .id = 0,
    .name = "none"
};

फिर, आप उसके employeeबाद अपने कोड में उपयोग कर सकते हैं ।

Question 13

एक संरचना के लिए एक आरंभीकरण फ़ंक्शन डिफ़ॉल्ट मान प्रदान करने का एक अच्छा तरीका है:

Mystruct s;
Mystruct_init(&s);

या इससे भी कम:

Mystruct s = Mystruct_init();  // this time init returns a struct

Question 14

डिफ़ॉल्ट मानों के लिए एक और तरीका। संरचना के समान प्रकार के साथ एक प्रारंभिक कार्य करें। अलग-अलग फ़ाइलों में बड़े कोड को विभाजित करते समय यह दृष्टिकोण बहुत उपयोगी है।

struct structType{
  int flag;
};

struct structType InitializeMyStruct(){
    struct structType structInitialized;
    structInitialized.flag = 3;
    return(structInitialized); 
};


int main(){
    struct structType MyStruct = InitializeMyStruct();
};

Question 15

आप इसके लिए एक फ़ंक्शन बना सकते हैं:

typedef struct {
    int id;
    char name;
} employee;

void set_iv(employee *em);

int main(){
    employee em0; set_iv(&em0);
}

void set_iv(employee *em){
    (*em).id = 0;
    (*em).name = "none";
}

Question 16

एक अन्य दृष्टिकोण, यदि संरचना इसकी अनुमति देती है, तो # डिफ़ॉल्ट मान के साथ #define का उपयोग करना है:

#define MYSTRUCT_INIT { 0, 0, true }

typedef struct
{
    int id;
    int flag;
    bool foo;
} MyStruct;

उपयोग:

MyStruct val = MYSTRUCT_INIT;

Question 17

मुझे लगता है कि आप इसे कर सकते हैं,

typedef struct
{
  int flag : 3;
} MyStruct;