मुझे किसी सरणी की लंबाई कैसे पता चलेगी?

Question

क्या यह पता लगाने का एक तरीका है कि किसी सरणी में कितने मान हैं? यह पता लगाना कि मैं किसी सरणी के अंत तक पहुँचा हूँ या नहीं, यह भी काम करेगा।

Comments

सरणी कहाँ से आ रही है? आमतौर पर फ़ंक्शंस लेने वाले फ़ंक्शन भी इस समस्या से निपटने के लिए एक लंबा पैरामीटर लेते हैं।

— माइकल मायर्स

खैर, मैं एक "पागल काम" कार्यक्रम बना रहा हूं, जिसमें सभी पाठों के साथ एक सरणी है, साथ ही संज्ञाओं / क्रियाओं के स्थान जो उपयोगकर्ता को भरना है। मैं एक फ़ंक्शन का उपयोग करना चाहूंगा। संपूर्ण सरणी, "[संज्ञा]" और "[क्रिया]" के स्थान पर उपयोगकर्ता द्वारा दर्ज किए गए पाठ के साथ मान।

— मैक्सएम

सरणी

— अधिकतम दोपहर ३०'११

कृपया ध्यान दें कि सी सरणियों में ऑब्जेक्ट या संरचनाएं नहीं हैं। जैसे, उनके पास डिफ़ॉल्ट रूप से कहीं भी कोई लंबाई पैरामीटर संग्रहीत नहीं है। यदि आप उनके साथ C ++ में ऑब्जेक्ट्स के रूप में काम करना चाहते हैं, तो C ++ ऑब्जेक्ट्स का उपयोग कर सकते हैं: वेक्टर, या std :: यदि आप कर सकते हैं। यदि आपको पॉइंटर्स का उपयोग करना है, तो हमेशा इसके साथ काम करने वाले प्रत्येक फ़ंक्शन के लिए दूसरे पैरामीटर के रूप में सरणी की लंबाई पास करें।

— पिहान

यदि आप C ++ 20 का उपयोग कर रहे हैं, तो मैंने उसके लिए भी उत्तर जोड़ा है। इसे आसानी से याद किया जा सकता है क्योंकि यहाँ बहुत सारे उत्तर हैं।

— gprathour

Answer 1

यदि आपका मतलब सी-स्टाइल ऐरे से है, तो आप कुछ ऐसा कर सकते हैं:

int a[7];
std::cout << "Length of array = " << (sizeof(a)/sizeof(*a)) << std::endl;

यह संकेत पर काम नहीं करता है (यानी यह निम्नलिखित में से किसी के लिए भी काम नहीं करेगा ):

int *p = new int[7];
std::cout << "Length of array = " << (sizeof(p)/sizeof(*p)) << std::endl;

या:

void func(int *p)
{
    std::cout << "Length of array = " << (sizeof(p)/sizeof(*p)) << std::endl;
}

int a[7];
func(a);

सी ++ में, यदि आप इस तरह का व्यवहार चाहते हैं, तो आपको कंटेनर क्लास का उपयोग करना चाहिए; शायद std::vector।

Comments

यह भी काम नहीं करता है अगर आप किसी भिन्न फ़ंक्शन में सरणी पास करते हैं और इसे वहां करने की कोशिश करते हैं :)

— सैन जैसिंटो

@ शान जैसिंटो: नहीं, यह काम करता है ( सरणियों पर ) कोई फर्क नहीं पड़ता कि आप किस कार्य में हैं। एक पैरामीटर के रूप में फ़ंक्शन के लिए चर लंबाई की एक सरणी पास करना, हालांकि, यह असंभव है (यह एक सूचक में तय होता है) - लेकिन अगर आप पास करते हैं एक संरचना के अंदर सरणी, फिर यह उम्मीद के मुताबिक काम करता है।

— eq-

@OliverCharlesworth भी अगर आप किसी अन्य फ़ंक्शन के लिए मान द्वारा सरणी पारित किया है और वहाँ की कोशिश की, यह काम नहीं करेगा, है ना? सवाल यह है कि

— A_Matar

@A_Matar - आप C या C ++ में मान द्वारा कोई सरणी पास नहीं कर सकते।

— ओलिवर चार्ल्सवर्थ

@yusha - वे एक ही बात कर रहे हैं।

— ओलिवर चार्ल्सवर्थ

Answer 2

जैसा कि अन्य ने कहा है कि आप इसका उपयोग कर सकते हैं sizeof(arr)/sizeof(*arr) लेकिन यह आपको सूचक प्रकारों के लिए गलत उत्तर देगा जो कि सरणियाँ नहीं हैं।

template<class T, size_t N>
constexpr size_t size(T (&)[N]) { return N; }

यह गैर सरणी प्रकार (दृश्य स्टूडियो के लिए संकलन करने में विफल होने की अच्छी संपत्ति है) _countof ऐसा होता है)। constexprतो यह मैक्रो पर कोई कमियां नहीं है (कम से कम कोई भी मैं के बारे में पता) यह एक संकलन समय अभिव्यक्ति बना देता है।

आप std::arrayC ++ 11 का उपयोग करने पर भी विचार कर सकते हैं जो अपनी लंबाई को एक देशी C सरणी पर ओवरहेड के साथ उजागर करता है।

सी ++ 17 है std::size()में <iterator>शीर्ष लेख है जो एक ही करता है और एसटीएल कंटेनर भी (करने के लिए धन्यवाद के लिए काम करता @Jon सी )।

Comments

@yau यह है कि आप किसी सरणी के संदर्भ को कैसे लिखते हैं , इस उत्तर को देखें । जब तक पैरामीटर का उपयोग नहीं किया जाता है, तब से मेरा संस्करण थोड़ा अलग दिखता है, क्योंकि पैरामीटर का उपयोग नहीं किया गया है, केवल इसके प्रकार की आवश्यकता है। एक नाम के साथ यह होगा T(arg&)[N]।

— मोति

धन्यवाद Motti! मेरे द्वारा छोड़ा गया पैरामीटर नाम पहले से ही स्पष्ट था। लेकिन अविश्वसनीय है कि मैं जाहिरा तौर पर पहले कभी arrays के लिए रेफरी / संकेत का कोई फायदा नहीं था । और शायद भविष्य में ऐसा नहीं होगा, क्योंकि इस तरह के सरणियां और भी अधिक मर रही हैं।

— यॉ

blogs.msdn.microsoft.com/the1/2004/05/07/…

— Vincent Scheib

यदि C ++ 11 का उपयोग नहीं किया जाता है तो :: बेहतर समाधान की सीमा ???? en.cppreference.com/w/cpp/types/extent

— इसहाक पास्कल

@IsaacPascual से मैं परिचित नहीं था extent, अब इसे देखते हुए इसके साथ दो विशेषताएँ हैं जो इसे ऊपर दिए गए फ़ंक्शन (इस usecase के लिए) की तुलना में कम उपयोगी बनाती हैं। (1) यह पॉइंटर्स के लिए शून्य देता है (संकलन त्रुटि के बजाय)। (२) इसके लिए एक प्रकार के पैरामीटर की आवश्यकता होती है ताकि एक चर की जाँच करने के लिए आपको करना होगाdecltype

— मोत्ती १६'१:

Answer 3

करने sizeof( myArray )से आपको उस सरणी के लिए आवंटित बाइट्स की कुल संख्या मिल जाएगी। तब आप सरणी में एक तत्व के आकार से विभाजित करके सरणी में तत्वों की संख्या का पता लगा सकते हैं:sizeof( myArray[0] )

Comments

यह एक बहुत ही सरल और आसान उपाय है जिसे दूर करने के लिए एक उम्र पुरानी समस्या लगती है।

एक सूचक द्वारा आयोजित C ++ "नई" सरणियों के लिए काम नहीं करता है। यदि आप इसे रोकते हैं तो आपको पॉइंटर का आकार (4 बाइट) या उसके पहले तत्व का आकार मिलता है।

— ड्रैगनलॉर्ड

@DragonLord हाँ, हालाँकि कोई भी व्यक्ति कीवर्ड का उपयोग करके ऐरे के आकार की घोषणा करता है, पहले से ही रनटाइम पर एरे के आकार को पहले ही जान लेगा, इसलिए उस स्थिति में एरे के आकार को खोजने के लिए साइज़ोफ़ ऑपरेटर का उपयोग करने की कोई आवश्यकता नहीं है। मुझे यकीन है कि आप जानते हैं कि। यह किसी के भी लाभ के लिए है जो नहीं करता है।

— मार्टीन शट

@ सूरेगा यह दुर्घटनाग्रस्त नहीं होगा

— सीआईटीबीएल

Answer 4

हालांकि यह एक पुराना सवाल है, यह C ++ 17 के जवाब को अपडेट करने लायक है। मानक पुस्तकालय में अब टेम्पर्ड फंक्शन है std::size(), जो एक std कंटेनर या C- स्टाइल एरे दोनों में तत्वों की संख्या लौटाता है। उदाहरण के लिए:

#include <iterator>

uint32_t data[] = {10, 20, 30, 40};
auto dataSize = std::size(data);
// dataSize == 4

Answer 5

क्या यह पता लगाने का एक तरीका है कि किसी सरणी में कितने मान हैं?

हाँ!

प्रयत्न sizeof(array)/sizeof(array[0])

यह पता लगाना कि मैं किसी सरणी के अंत तक पहुँचा हूँ या नहीं, यह भी काम करेगा।

मुझे इसके लिए कोई रास्ता नहीं दिख रहा है जब तक कि आपका सरणी वर्णों का एक सरणी (यानी स्ट्रिंग) नहीं है।

PS: C ++ में हमेशा उपयोग करते हैं std::vector। कई इनबिल्ट फ़ंक्शंस और एक विस्तारित कार्यक्षमता है।

Comments

यह वैरिएबल इंडिविजुअल ऐरे साइज के लिए काम नहीं करेगा

— डॉन लैरींक्स

वैक्टर के लिए +1। पुरानी शैली C ++ सरणियों का उपयोग करने के लिए बहुत कम मजबूत मामले हैं। जब तक सरणी का आकार कभी बदलने वाला नहीं है, लेकिन तब भी, आपको इसके बजाय सरणी कंटेनर वर्ग का उपयोग करना चाहिए। डायनामिक ऐरे स्टोरेज के लिए वेक्टर जैसे कंटेनर क्लास का इस्तेमाल करना बेहतर है। कंटेनर कक्षाओं का उपयोग करने के पेशेवरों ने आपकी स्मृति का प्रबंधन करने की विपक्ष को पछाड़ दिया।

— मार्तीन शट

@MartynShutt जब आप कैश-बाउंड होते हैं, तो gamedev की तरह, आप कभी-कभी एक वेक्टर का उपयोग करने का जोखिम नहीं उठा सकते हैं।

— तारा

Answer 6

std::vectorएक विधि है size()जो वेक्टर में तत्वों की संख्या लौटाती है।

(हां, यह जुबान-इन-गाल जवाब है)

Comments

गाल में जीभ यह हो सकता है, लेकिन यह लगभग निश्चित रूप से सही दृष्टिकोण है।

— जेरी कॉफिन

आप यह क्यों कहते हैं कि यह गाल में जीभ है? मेरे लिए (एक c ++ नौसिखिया) यह सिर्फ सही जवाब की तरह लगता है।

— dbliss

@ डब्लिस यह जीभ-इन-गाल है, क्योंकि ओपी ने एक सरणी और eq की लंबाई के बारे में पूछा था - उन्हें बताता है कि वेक्टर की लंबाई कैसे प्राप्त की जाए , जो C ++ में एक अलग चीज है। हालाँकि, यह एक गहरे स्तर पर सही है क्योंकि यदि आपको रन टाइम पर लंबाई प्राप्त करने की आवश्यकता है, तो वेक्टर बहुत बेहतर विकल्प है ।

— पूलि

आप std :: सूची या कुछ अन्य कंटेनरों का भी उपयोग कर सकते हैं जो मुझे विश्वास है।

— BuvinJ

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

— BuvinJ

Answer 7

#include <iostream>

int main ()
{
    using namespace std;
    int arr[] = {2, 7, 1, 111};
    auto array_length = end(arr) - begin(arr);
    cout << "Length of array: " << array_length << endl;
}

Comments

मेरा मानना ​​है कि यह केवल स्थानीय चर के लिए काम करता है जो स्टैक पर हैं।

— ड्रैगनलॉर्ड

यह सबसे अच्छा जवाब है। @DragonLord, यह सदस्य संस्करण के लिए भी काम करता है। Cpp.sh/92xvv देखें ।

— शीतल शाह

Answer 8

सी ++ 11 के बाद से, सरणी की लंबाई के साथ काम करते समय दर्द को कम करने में मदद करने के लिए कुछ नए टेम्पलेट पेश किए जाते हैं। उन सभी को हेडर में परिभाषित किया गया है <type_traits>।

• std::rank<T>::value

  यदि Tएक सरणी प्रकार है, तो सदस्य को सरणी के आयामों की संख्या के बराबर निरंतर मूल्य प्रदान करता है। किसी अन्य प्रकार के लिए, मान 0 है।

• std::extent<T, N>::value

  यदि Tएक सरणी प्रकार है, तो सदस्य Nको सरणी के वें आयाम के साथ तत्वों की संख्या के बराबर निरंतर मान प्रदान करता है , यदि Nयह [0, में है std::rank<T>::value)। किसी भी अन्य प्रकार के लिए, या यदि Tइसका पहला आयाम अज्ञात अज्ञात है और N0 है, तो मान 0 है।

• std::remove_extent<T>::type

  यदि Tकिसी प्रकार का एक सरणी है X, तो सदस्य को टाइप के रूप में टाइपफ़ीड प्रदान करता है X, अन्यथा प्रकार है T। ध्यान दें कि यदि Tएक बहुआयामी सरणी है, तो केवल पहला आयाम हटा दिया जाता है।

• std::remove_all_extents<T>::type

  यदि Tकिसी प्रकार का एक बहुआयामी सरणी है X, तो सदस्य को टाइप के समान टाइपफ़ीड प्रदान करता है X, अन्यथा प्रकार है T।

एक बहुआयामी सरणी के किसी भी आयाम पर लंबाई प्राप्त करने के लिए, के decltypeसाथ संयोजन के लिए इस्तेमाल किया जा सकता है std::extent। उदाहरण के लिए:

#include <iostream>
#include <type_traits> // std::remove_extent std::remove_all_extents std::rank std::extent

template<class T, size_t N>
constexpr size_t length(T(&)[N]) { return N; }

template<class T, size_t N>
constexpr size_t length2(T(&arr)[N]) { return sizeof(arr) / sizeof(*arr); }

int main()
{
    int a[5][4][3]{{{1,2,3}, {4,5,6}}, { }, {{7,8,9}}};

    // New way
    constexpr auto l1 = std::extent<decltype(a)>::value;     // 5
    constexpr auto l2 = std::extent<decltype(a), 1>::value;  // 4
    constexpr auto l3 = std::extent<decltype(a), 2>::value;  // 3
    constexpr auto l4 = std::extent<decltype(a), 3>::value;  // 0

    // Mixed way
    constexpr auto la = length(a);
    //constexpr auto lpa = length(*a);  // compile error
    //auto lpa = length(*a);  // get at runtime
    std::remove_extent<decltype(a)>::type pa;  // get at compile time
    //std::remove_reference<decltype(*a)>::type pa;  // same as above
    constexpr auto lpa = length(pa);
    std::cout << la << ' ' << lpa << '\n';

    // Old way
    constexpr auto la2 = sizeof(a) / sizeof(*a);
    constexpr auto lpa2 = sizeof(*a) / sizeof(**a);
    std::cout << la2 << ' ' << lpa2 << '\n';

    return 0;
}

एक बहु-विषयक सरणी में तत्वों की कुल संख्या प्राप्त करने के लिए BTY:

constexpr auto l = sizeof(a) / sizeof(std::remove_all_extents<decltype(a)>::type);

या इसे फंक्शन टेम्पलेट में रखें:

#include <iostream>
#include <type_traits>
    

template<class T>
constexpr size_t len(T &a)
{
    return sizeof(a) / sizeof(typename std::remove_all_extents<T>::type);
}

int main()
{
    int a[5][4][3]{{{1,2,3}, {4,5,6}}, { }, {{7,8,9}}};
    constexpr auto ttt = len(a);
    int i;
    std::cout << ttt << ' ' << len(i) << '\n';
    
    return 0;
}

लिंक का पालन करके उन्हें कैसे उपयोग किया जा सकता है, इसके अधिक उदाहरण।

Answer 9

TR1 / C ++ 11 / C ++ 17 तरीका भी है (इसे देखें Live on Coliru):

const std::string s[3] = { "1"s, "2"s, "3"s };
constexpr auto n       = std::extent<   decltype(s) >::value; // From <type_traits>
constexpr auto n2      = std::extent_v< decltype(s) >;        // C++17 shorthand

const auto     a    = std::array{ "1"s, "2"s, "3"s };   // C++17 class template arg deduction -- http://en.cppreference.com/w/cpp/language/class_template_argument_deduction
constexpr auto size = std::tuple_size_v< decltype(a) >;

std::cout << n << " " << n2 << " " << size << "\n"; // Prints 3 3 3

Answer 10

बिल्ट इन सरणी फंक्शन उर्फ ​​का उपयोग करने के बजाय:

 int x[3] = {0, 1, 2};

आपको एरे क्लास और एरे टेम्पलेट का उपयोग करना चाहिए। प्रयत्न:

#include <array>
array<type_of_the_array, number_of_elements_in_the_array> Name_of_Array = {};

तो अब अगर आप सरणी की लंबाई का पता लगाना चाहते हैं, तो आपको केवल कक्षा में आकार फ़ंक्शन का उपयोग करना होगा।

Name_of_Array.size();

और उस सरणी में तत्वों की लंबाई को वापस करना चाहिए।

Answer 11

C ++ में, एक सरणी घोषित करने के लिए std :: array class का उपयोग करके, कोई आसानी से एक सरणी का आकार और अंतिम तत्व भी पा सकता है।

#include<iostream>
#include<array>
int main()
{
    std::array<int,3> arr;

    //To find the size of the array
    std::cout<<arr.size()<<std::endl;

    //Accessing the last element
    auto it=arr.end();
    std::cout<<arr.back()<<"\t"<<arr[arr.size()-1]<<"\t"<<*(--it);

    return 0;
}

---

वास्तव में, सरणी वर्ग में कई अन्य कार्य हैं जो हमें एक मानक कंटेनर का उपयोग करते हैं।
संदर्भ 1 से C ++ std :: सरणी वर्ग
संदर्भ 2 से std :: सरणी वर्ग
संदर्भ में उदाहरण सहायक हैं।

Comments

अच्छा; मैं देख रहा हूँ कि आपको कई कौशल मिले; और ... महान दृष्टिकोण। मुझे लगता है कि इस तरह के प्रसिद्ध सवालों के जवाब खुद भी लिखना चाहिए ;-)

— घोस्टकट

Answer 12

यह बहुत पुराना और पौराणिक सवाल है और वहाँ पहले से ही कई अद्भुत जवाब हैं। लेकिन समय के साथ भाषाओं में नई कार्यक्षमताएँ जुड़ती जा रही हैं, इसलिए हमें उपलब्ध नई सुविधाओं के अनुसार चीजों को अपडेट करते रहना चाहिए।

मैंने अभी तक C ++ 20 के बारे में कोई भी उल्लेख नहीं किया है। तो जवाब लिखने की सोची।

सी ++ 20

C ++ 20 में, सरणी की लंबाई अर्थात की खोज के लिए मानक पुस्तकालय में एक नया बेहतर तरीका जोड़ा गया है std:ssize()। यह फ़ंक्शन देता है a signed value।

#include <iostream>

int main() {
    int arr[] = {1, 2, 3};
    std::cout << std::ssize(arr);
    return 0;
}

सी ++ 17

C ++ 17 में उसी के लिए एक बेहतर तरीका (उस समय) था जिसे std::size()परिभाषित किया गया है iterator।

#include <iostream>
#include <iterator> // required for std::size

int main(){
    int arr[] = {1, 2, 3};
    std::cout << "Size is " << std::size(arr);
    return 0;
}

पुनश्च यह विधि भी काम करती है vector।

पुराना

यह पारंपरिक दृष्टिकोण पहले से ही कई अन्य उत्तरों में उल्लिखित है।

#include <iostream>

int main() {
    int array[] = { 1, 2, 3 };
    std::cout << sizeof(array) / sizeof(array[0]);
    return 0;
}

सिर्फ FYI करें, अगर आपको आश्चर्य हो कि जब यह सरणी किसी अन्य फ़ंक्शन के लिए पास हो जाती है तो यह दृष्टिकोण काम क्यों नहीं करता है । कारण यह है की,

C ++ में किसी मान को अरैस्ट नहीं किया जाता है, इसके बजाय पॉइंटर टू ऐरे पास किया जाता है। जैसा कि कुछ मामलों में पूरे सरणियों को पारित करना महंगा ऑपरेशन हो सकता है। आप सरणी को किसी फ़ंक्शन में पास करके इसका परीक्षण कर सकते हैं और वहां सरणी में कुछ बदलाव कर सकते हैं और फिर सरणी को मुख्य रूप से प्रिंट कर सकते हैं। आपको अद्यतन परिणाम मिलेंगे।

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

लेकिन मुझे यकीन है कि आप अपनी आवश्यकता के अनुसार ऐसा करने का एक अच्छा तरीका पा सकते हैं।

हैप्पी कोडिंग।

Answer 13

आपके पास C सरणी आकार प्राप्त करने के लिए उपयोग किए जाने वाले विकल्पों का एक गुच्छा है।

int myArray [] = {0, 1, 2, 3, 4, 5, 7};

1) sizeof(<array>) / sizeof(<type>):

std::cout << "Size:" << sizeof(myArray) / sizeof(int) << std::endl;

2) sizeof(<array>) / sizeof(*<array>):

std::cout << "Size:" << sizeof(myArray) / sizeof(*myArray) << std::endl;

3) sizeof(<array>) / sizeof(<array>[<element>]):

std::cout << "Size:" << sizeof(myArray) / sizeof(myArray[0]) << std::endl;

Answer 14

Google ProtobufArraySize से एक कार्यान्वयन यहां दिया गया है ।

#define GOOGLE_ARRAYSIZE(a) \
  ((sizeof(a) / sizeof(*(a))) / static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))

// test codes...
char* ptr[] = { "you", "are", "here" };
int testarr[] = {1, 2, 3, 4};
cout << GOOGLE_ARRAYSIZE(testarr) << endl;
cout << GOOGLE_ARRAYSIZE(ptr) << endl;

ARRAYSIZE (गिरफ्तार) साइज़ोफ़ (गिरफ्तारी) (सरणी में बाइट्स का #) और साइज़ोफ़ (* (गिरफ्तार)) (एक सरणी तत्व में बाइट्स का #) निरीक्षण करके काम करता है। यदि पूर्व को उत्तरार्द्ध द्वारा विभाज्य है, तो शायद गिरफ्तारी वास्तव में एक सरणी है, इस मामले में विभाजन परिणाम सरणी में तत्वों का # है। अन्यथा, गिरफ्तारी संभवतः एक सरणी नहीं हो सकती, और हम कोड को संकलित होने से रोकने के लिए एक संकलक त्रुटि उत्पन्न करते हैं।

चूँकि बूल का आकार कार्यान्वयन-परिभाषित है, इसलिए हमें अंतिम परिणाम प्रकार type_t है यह सुनिश्चित करने के लिए size_t को (sizeof) (a) और sizeof (* (a)) को कास्ट करना होगा।

यह मैक्रो सही नहीं है क्योंकि यह गलत तरीके से कुछ बिंदुओं को स्वीकार करता है, जहां पॉइंटर का आकार पॉइंटी आकार से विभाज्य है। चूंकि हमारे सभी कोड को 32-बिट कंपाइलर से गुजरना पड़ता है, जहां एक पॉइंटर 4 बाइट्स होता है, इसका मतलब है कि सभी पॉइंटर एक प्रकार के हैं जिनका आकार 3 या 4 से अधिक है (राइटली) अस्वीकार कर दिया जाएगा।

Comments

इस तरह पूर्णांक की एक सरणी के साथ: int nombres[5] = { 9, 3 };इस समारोह के 5बजाय लौटता है 2।

— अनवर

GOOGLE_ARRAYSIZE(new int8_t)8त्रुटि बढ़ाने के बजाय, मेरी परीक्षा एनवी पर लौटती है । कास्ट वाला हिस्सा बेमानी लगता है, चिल्लाते हुए सी मैक्रो का उल्लेख नहीं करता है। sizeof(a) / sizeof(*a)विरासत समाधान के रूप में पर्याप्त तरीके से काम करता है।

Answer 15

C ++ / CX के लिए (जब Visual Studio में C ++ का उपयोग करके UWP एप्लिकेशन लिखते हैं) तो हम केवल size()फ़ंक्शन का उपयोग करके किसी सरणी में मानों की संख्या पा सकते हैं ।

सोर्स कोड:

string myArray[] = { "Example1", "Example2", "Example3", "Example4" };
int size_of_array=size(myArray);

आप तो उत्पादन होगा:coutsize_of_array

>>> 4

Answer 16

sizeof(array_name)पूरे सरणी sizeof(int)का आकार देता है और हर प्रकार के तत्व के डेटा प्रकार का आकार देता है।

इसलिए सरणी के एकल तत्व के आकार से पूरे सरणी के आकार को विभाजित करना सरणी की लंबाई देता है ।

 int array_name[] = {1, 2, 3, 4, 5, 6};
 int length = sizeof(array_name)/sizeof(int);

Comments

हालांकि यह कोड स्निपेट समस्या को हल कर सकता है, यह इस बात की व्याख्या नहीं करता है कि यह प्रश्न का उत्तर क्यों या कैसे देता है। कृपया अपने कोड के लिए एक स्पष्टीकरण शामिल करें, क्योंकि यह वास्तव में आपके पोस्ट की गुणवत्ता में सुधार करने में मदद करता है। याद रखें कि आप भविष्य में पाठकों के लिए प्रश्न का उत्तर दे रहे हैं, और उन लोगों को आपके कोड सुझाव के कारणों का पता नहीं चल सकता है

— बालागुुरुनाथन मारीमुथु

Answer 17

उत्तर :

int number_of_elements = sizeof(array)/sizeof(array[0])

शोषण :

चूंकि कंपाइलर प्रत्येक प्रकार के डेटा के लिए मेमोरी का एक विशिष्ट आकार अलग-अलग सेट करता है, और एक सरणी केवल उन लोगों का एक समूह होता है, आप बस डेटा प्रकार के आकार द्वारा सरणी के आकार को विभाजित करते हैं। यदि मेरे पास 30 स्ट्रिंग्स हैं, तो मेरा सिस्टम ऐरे के प्रत्येक तत्व (स्ट्रिंग) के लिए 24 बाइट्स को अलग करता है। 30 तत्वों पर, यह कुल 720 बाइट्स है। 720/24 == 30 तत्व। उस के लिए छोटा, तंग एल्गोरिथ्म है:

int number_of_elements = sizeof(array)/sizeof(array[0]) जिसके बराबर है

number_of_elements = 720/24

ध्यान दें कि आपको यह जानने की आवश्यकता नहीं है कि सरणी डेटा किस प्रकार का है, भले ही वह कस्टम डेटा प्रकार हो।

Comments

2019 में इस पुरातन और त्रुटि प्रवण दृष्टिकोण की कोई आवश्यकता नहीं है। stackoverflow.com/a/59109106/560648 इसके अलावा यह मौजूदा उत्तरों का एक मात्र है।

— लपट दौड़ कक्षा में

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

— बॉब वार्नर

Answer 18

बस एक विचार, लेकिन सिर्फ एक काउंटर वेरिएबल बनाने और स्थिति आकार को स्टोर करने का फैसला किया [0]। मैंने फ़ंक्शन में अधिकांश कोड हटा दिए थे, लेकिन आप लूप से बाहर निकलने के बाद देखेंगे, प्राइम [0] को 'a' का अंतिम मान दिया गया है। मैंने वैक्टर का उपयोग करने की कोशिश की लेकिन वीएस एक्सप्रेस 2013 को यह बहुत पसंद नहीं आया। यह भी नोट करें कि 'a' ओवरराइटिंग से बचने के लिए एक पर शुरू होता है [0] और त्रुटियों से बचने के लिए इसे शुरुआत में शुरू किया जाता है। मैं कोई विशेषज्ञ नहीं हूं, बस सोचा था कि मैं साझा करूंगा।

int prime[] = {0};
int primes(int x, int y){
    using namespace std; int a = 1;
    for (int i = x; i <= y; i++){prime[a] = i; a++; }
    prime[0] = a; return 0;
}

Answer 19

एक अच्छा समाधान जो जेनरिक का उपयोग करता है:

template <typename T,unsigned S>
inline unsigned arraysize(const T (&v)[S]) { return S; }

फिर arraysize(_Array);सरणी की लंबाई प्राप्त करने के लिए बस कॉल करें ।

स्रोत

Comments

@bobogo इनलाइन या कॉन्स्टैक्स के साथ काम करता है, हो सकता है कि आपने इनलाइन बंद कर दिया हो या यह वैकल्पिक हो? ideone.com/VxogJ4

— QuentinUK

@QentinUK constexprठीक है। inlineनहीं है। constexprहालांकि बहुत आधुनिक है। क्या आप सुनिश्चित हैं कि आपका परीक्षण कार्यक्रम किसी अन्य आधुनिक सुविधा का उपयोग नहीं कर रहा है, जहां आप एक स्थानीय सरणी की घोषणा कर सकते हैं जिसकी लंबाई एक चर द्वारा दी गई है? इसे दो वैश्विक सरणियों के साथ आज़माएं।

— बॉबबोगो

Answer 20

पुराने g ++ कंपाइलर के लिए, आप ऐसा कर सकते हैं

template <class T, size_t N>
char (&helper(T (&)[N]))[N];

#define arraysize(array) (sizeof(helper(array)))

int main() {
    int a[10];
    std::cout << arraysize(a) << std::endl;
    return 0;
}

Comments

यह सही जवाब है। C ++ संस्करणों के बीच बहुत पोर्टेबल, पॉइंटर्स के साथ काम नहीं करता है, साथ ही जवाब संकलन समय पर उपलब्ध है

— bobbogo

Answer 21

मैं यहां एक मुश्किल समाधान प्रदान करता हूं:

आप हमेशा lengthपहले तत्व में स्टोर कर सकते हैं :

// malloc/new

arr[0] = length;
arr++;

// do anything. 
int len = *(arr-1);

free(--arr); 

लागत है तो आपको --arrजब आह्वानfree

Comments

यह तभी काम करता है जब arrप्रकार एक प्रकार से संगत हो intऔर सरणी प्रकार के अधिकतम मान से अधिक लंबा न हो। उदाहरण के पास्कल स्ट्रिंग्स वास्तव में इस ट्रिक का उपयोग करके बाइट ऐरे हैं; पास्कल में तार की अधिकतम लंबाई 255 वर्ण है।

— पलक

मुझे लगता है कि एक व्यक्ति प्रत्येक सरणी की शुरुआत में 8 बाइट्स आरक्षित कर सकता है और यदि वे वस्तुओं को संग्रहीत करना चाहते हैं तो एक अहस्ताक्षरित लंबे समय का उपयोग कर सकते हैं। मुझे लगता है कि एक वेक्टर शायद आसान है। लेकिन निश्चित रूप से एम्बेडेड सिस्टम के लिए एक अच्छा समाधान है।

— aj.toulan

Answer 22

आप निम्न द्वारा एक ऐरे की लंबाई पा सकते हैं:

int  arr[] = {1, 2, 3, 4, 5, 6}; 
int size = *(&arr + 1) - arr; 
cout << "Number of elements in arr[] is "<< size; 
return 0;

Comments

सरलीकृत (और गिरफ्तार) [1] - गिरफ्तारी;

— क्वेंटिनुक

Answer 23

बस आप इस स्निपेट का उपयोग कर सकते हैं:

#include <iostream>
#include <string>
#include <array>

using namespace std;

int main()
{

  array<int,3> values;
  cout << "No. elements in valuea array: " << values.size() << " elements." << endl;
  cout << "sizeof(myints): " << sizeof(values) << endl;

}

और यहाँ संदर्भ है: http://www.cplusplus.com/reference/array/array/size/

Answer 24

साइज़ोफ़ के साथ टाइप के उपयोग से बचें, जैसा कि sizeof(array)/sizeof(char) , यदि आप सरणी के प्रकार को बदलते हैं तो अचानक भ्रष्ट हो जाता है।

दृश्य स्टूडियो में, यदि आपके पास समतुल्य है sizeof(array)/sizeof(*array)। आप बस टाइप कर सकते हैं_countof(array)

Answer 25

मैं व्यक्तिगत रूप से सुझाव दूंगा (यदि आप जो भी कारण के लिए विशेष कार्यों के साथ काम करने में असमर्थ हैं) सबसे पहले सरणियों के प्रकार की संगतता का विस्तार करें जो आप सामान्य रूप से इसका उपयोग करेंगे (यदि आप मूल्यों को संग्रहीत कर रहे थे ≥ 0:

unsigned int x[] -> int x[]

की तुलना में आप इसे बनाने के लिए जरूरत की तुलना में सरणी 1 तत्व को बड़ा करेंगे। अंतिम तत्व के लिए आप कुछ प्रकार डालेंगे जो कि विस्तारित प्रकार के विनिर्देशक में शामिल है, लेकिन यह कि आप सामान्य रूप से उपयोग नहीं करेंगे, पिछले उदाहरण का उपयोग करते हुए अंतिम तत्व -1 होगा। यह आपको एक सरणी के अंतिम तत्व को खोजने के लिए (लूप के लिए उपयोग करके) सक्षम करता है।

Answer 26

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

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

यदि आप एक आदिम सरणी के लिए एसटीएल कंटेनर के विकल्प के साथ जाते हैं, तो यह एसओ पद इसे आरंभ करने के तरीकों के लिए आपके लिए उपयोग हो सकता है: एसटीडी को आरंभीकृत करने का सबसे आसान तरीका क्या है : हार्डकोड तत्वों के साथ वेक्टर?

यहाँ एक विधि है जो मैं इसके लिए उपयोग कर रहा हूं जो संकलक और प्लेटफार्मों पर सार्वभौमिक रूप से काम करेगा:

अपने संग्रह के लिए कंटेनर के रूप में एक संरचना या वर्ग बनाएं। << के लिए एक ऑपरेटर अधिभार समारोह को परिभाषित करें।

class MyObject;

struct MyObjectList
{
    std::list<MyObject> objects;
    MyObjectList& operator<<( const MyObject o )
    { 
        objects.push_back( o );
        return *this; 
    }
};

आप ऐसे कार्य बना सकते हैं जो आपकी संरचना को एक पैरामीटर के रूप में लेते हैं, जैसे:

someFunc( MyObjectList &objects );

फिर, आप इस तरह से उस फ़ंक्शन को कॉल कर सकते हैं:

someFunc( MyObjectList() << MyObject(1) <<  MyObject(2) <<  MyObject(3) );

इस तरह, आप एक सिंगल क्लीन लाइन में फ़ंक्शन के लिए गतिशील रूप से आकार के संग्रह का निर्माण और पास कर सकते हैं!

Answer 27

कहते हैं कि आपके पास पृष्ठ के शीर्ष पर घोषित एक वैश्विक सरणी है

int global[] = { 1, 2, 3, 4 };

यह जानने के लिए कि सरणी में कितने तत्व हैं (c ++ में) निम्न कोड टाइप करें:

sizeof(global) / 4;

Sizeof (NAME_OF_ARRAY) / 4 आपको दिए गए सरणी नाम के लिए तत्वों की संख्या वापस देगा।

Comments

sizeof (int) प्लेटफॉर्म पर निर्भर है। इसमें कोई गारंटी नहीं है कि यह 4 होगा (हालांकि यह सबसे सामान्य मामला है)

— विजेता

इसके अलावा आप के लिए

— मिक्सी

मैजिक नंबर !!

— ऑर्बिट