सी: किसी सरणी में तत्वों की संख्या ढूंढना []

Question

सी में: फ़ंक्शन पर भेजने के बाद, आपको structs की सरणी में तत्वों की संख्या कैसे मिलती है?

int main(void) { 
    myStruct array[] = { struct1, struct2, struct3, struct4, struct5, struct6 }; 
    printf("%d\n", sizeof(array)); 
    printf("%d\n", sizeof(array[0])); 
    f(array); 
} 
void f(myStruct* array) { 
    printf("%d\n", sizeof(array)); 
    printf("%d\n", sizeof(array[0])); 
} 

किसी कारण से मुख्य में printf f में printf से अलग-अलग परिणाम दिखाता है। मेरी आवश्यकता यह जानना है कि सरणी में कितने तत्व हैं।

Answer 1

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

आप कार्य करने के लिए आकार पारित करने के लिए, उदाहरण के लिए है:

void f(myStruct* array, size_t siz); 

यह भी ध्यान दें f सरणी में, एक सूचक है कि जब तक main में यह एक सरणी है। Arrays और पॉइंटर्स अलग-अलग चीजें हैं।

Answer 2

एफ array में एक सूचक है, मुख्य array में एक सरणी है।

Answer 3

आप सी में लगातार किसी सरणी में तत्वों की संख्या नहीं बता सकते हैं। विशेष रूप से यदि आप पॉइंटर्स के माध्यम से सरणी पास करते हैं।

आमतौर पर, यदि आप फ़ंक्शन में सरणी आकार का उपयोग करना चाहते हैं, तो इसे पैरामीटर के रूप में पास करें।

Answer 4

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

आकार प्राप्त करने का एक आम तरीका सरणी घोषित करना है और फिर एक तत्व के आकार से कुल आकार को विभाजित करके तुरंत सरणी तत्व गणना प्राप्त करें। इस तरह:

struct my_struct my_struct_array[] = { 
{"data", 1, "this is data"}, 
{"more data", 2, "this is more data"}, 
{"yet more", 0, "and again more data"} 
}; 
const size_t my_struct_array_count = sizeof(my_struct_array)/sizeof(my_struct_array[0]); 

Answer 5

जब आप sizeofmain में उपयोग करते हैं, तो यह सरणी का मूल्यांकन कर रहा है, और वास्तविक सरणी का आकार देता है।

आप f में sizeof का उपयोग करते हैं, तो आप एक समारोह के लिए एक तर्क के रूप सरणी के नाम उत्तीर्ण कर ली है, तो यह एक सूचक को सड़ा हुआ है, इसलिए sizeof आप एक सूचक के आकार के बारे में बताता है।

आम तौर पर, यदि आप किसी फ़ंक्शन में सरणी पास करते हैं, तो आपको केवल एक विशिष्ट आकार के सरणी के साथ काम करने के लिए फ़ंक्शन लिखना होगा, या किसी विशेष आमंत्रण के साथ काम करने के लिए स्पष्ट रूप से सरणी के आकार को पास करना होगा।

Answer 6

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

Answer 7

C reference कहता है, आप तब तक ऐसा नहीं कर सकते जब तक कि अंतिम तत्व अद्वितीय न हो या आप फ़ंक्शन में सरणी तत्वों की गिनती पास न करें।

Answer 8

आपको सरणी को एक विशेष मूल्य के साथ समाप्त करना होगा और फ़ंक्शन में आपको उस मान पर गिनना होगा, यह है कि कैसे strlen() काम करता है यह शून्य '\ 0' मान तक गिना जाता है।

Answer 9

आप अपने सरणी के लिए प्रारूप का उपयोग कर सकते हैं। मैं स्ट्रिंग तत्वों का उपयोग कर रहा हूं, इसे संरचना के लिए काम करना चाहिए।

#define NULL "" 
#define SAME 0 

static char *check[] = { 
     "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256", 
     "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes", 
     "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea", 
     "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", "fcrypt", 
     "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320", 
     "lzo", "cts", "zlib", NULL 
}; // 38 items, excluding NULL 

मुख्य()

char **algo = check; 
int numberOfAlgo = 0; 


while (SAME != strcmp(algo[numberOfAlgo], NULL)) { 
    printf("Algo: %s \n", algo[numberOfAlgo++]); 
} 

printf("There are %d algos in the check list. \n", numberOfAlgo); 

आप उत्पादन मिलना चाहिए में

: वैकल्पिक रूप से

Algo: des 
    : 
    : 
Algo: zlib 

There are 38 algos in the check list. 

, आप शून्य का उपयोग नहीं करना चाहते हैं, इस के बजाय कार्य करें:

numberOfAlgo = 0; 

while (*algo) { 
    printf("Algo: %s \n", *algo); 
    algo++;   // go to the next item 
    numberOfAlgo++; // count the item 
} 

printf("There are %d algos in the check list. \n", numberOfAlgo); 

Answer 10

अपने समाधान के लिए एक उदाहरण के रूप में:

को देखते हुए

struct contain { 
char* a;  // 
int allowed; // 

struct suit { 
    struct t { 
      char* option; 
      int count; 
    } t; 

    struct inner { 
      char* option; 
      int count; 
    } inner; 
} suit; 
}; 

// जैसे। मुख्य में

 struct contain structArrayToBeCheck[] = { 
    { 
     .a = "John", 
     .allowed = 1, 

     .suit = { 
      .t = { 
       .option = "ON", 
       .count = 7 
      }, 

      .inner = { 
       .option = "OFF", 
       .count = 7 
      } 
     } 
    }, 
    { 
     .a = "John", 
     .allowed = 1, 

     .suit = { 
      .t = { 
       .option = "ON", 
       .count = 7 
      }, 

      .inner = { 
       .option = "OFF", 
       .count = 7 
      } 
     } 
    }, 
    { 
     .a = "John", 
     .allowed = 1, 

     .suit = { 
      .t = { 
       .option = "ON", 
       .count = 7 
      }, 

      .inner = { 
       .option = "OFF", 
       .count = 7 
      } 
     } 
    }, 
    { 
     .a = "John", 
     .allowed = 1, 

     .suit = { 
      .t = { 
       .option = "ON", 
       .count = 7 
      }, 

      .inner = { 
       .option = "OFF", 
       .count = 7 
      } 
     } 
    } 

}; 

प्रारंभ()

printf("Number of Struct within struct array: %d \n", sizeof(structArrayToBeCheck)/sizeof(struct contain)); 

आप सही उत्तर देता है।

Answer 11

ध्यान दें कि मुख्य() में, सरणी वास्तविक सरणी को संदर्भित करती है और इसलिए आकार() आवश्यक उत्तर देता है।

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

संभव समाधान

1.Declare हो सकता है सरणी विश्व स्तर पर

2.Pass समारोह पैरामीटर के रूप में सरणी आकार आशा है कि यह मदद करता है!