मैं चर आकार की एक श्रेणी कैसे घोषित कर सकता हूं (ग्लोबली)

Question

मैं एक ही लंबाई के तीन ऐरे बनाना चाहता हूं। प्रलेखन के अनुसार , Arrays को परिभाषित किया जाना चाहिए int myArray[10];जहां 10 को एक ज्ञात लंबाई (एक और पूर्णांक) के लिए प्रतिस्थापित किया जा सकता है, या एक सरणी से भरा जा सकता है {2, 3, 5, 6, 7}।

हालाँकि, जब मैंने एक मूल्य घोषित करने का प्रयास किया int arrSize = 10;और फिर उस आकार के आधार पर एक सरणी दी int myArray[arrSize];, तो मुझे निम्नलिखित मिले error: array bound is not an integer constant:।

वहाँ सरणी आकार को स्पष्ट रूप से निर्धारित करने का एक तरीका है, या क्या मुझे सिर्फ उन्हें हार्डकोड करने की आवश्यकता है? (मुझे सिखाया गया कि हार्डकोडिंग खराब है और हर कीमत पर इससे बचना चाहिए।)

Comments

मुझे भी ऐसी ही समस्या थी और मैंने ऐसा किया। मैं सीख रहा हूं इसलिए यह नहीं कह सकता कि यह वैध समाधान है या नहीं, लेकिन यह काम किया। वैक्टर का उपयोग करते हुए कोड के नीचे का हिस्सा देखें, मुझे उन्हें समझने के लिए शुरू करने में थोड़ा सा समय लगा और मैं अभी भी किसी भी तरह से विशेषज्ञ नहीं हूं: #include <string> #include <वेक्टर> #include <iostream> #include <एल्गोरिथम> #include <string.h> नेमस्पेस std का उपयोग; int main () {स्ट्रिंग नाम; स्ट्रिंग पता; तार शहर; स्ट्रिंग देश; स्ट्रिंग उत्तर; वेक्टर <वेक्टर <string> personData; के लिए (;) {वेक्टर <string> myTempData; cout << "प्रवेश करने के लिए नाम या n दर्ज करें" << endl; getline (सिनेमा, नाम); if (नाम == "n") {bre

— मिस्टरएक्सप

Answer 1

आपके प्रश्न के वास्तव में 2 भाग हैं।

1 / मैं सरणी के बाहर सरणी का निरंतर आकार कैसे घोषित कर सकता हूं?

आप या तो एक मैक्रो का उपयोग कर सकते हैं

#define ARRAY_SIZE 10
...
int myArray[ARRAY_SIZE];

या एक स्थिरांक का उपयोग करें

const int ARRAY_SIZE = 10;
...
int myArray[ARRAY_SIZE];

यदि आपने सरणी को आरंभीकृत किया है और आपको उसका आकार जानना है तो आप कर सकते हैं:

int myArray[] = {1, 2, 3, 4, 5};
const int ARRAY_SIZE = sizeof(myArray) / sizeof(int);

दूसरा sizeofआपके सरणी के प्रत्येक तत्व के प्रकार पर है, यहाँ int।

2 / मेरे पास एक सरणी कैसे हो सकती है जो आकार गतिशील है (यानी रनटाइम तक ज्ञात नहीं है)?

उसके लिए आपको गतिशील आवंटन की आवश्यकता होगी, जो Arduino पर काम करता है, लेकिन आमतौर पर इसकी सलाह नहीं दी जाती क्योंकि इससे "हीप" खंडित हो सकता है।

आप कर सकते हैं (सी तरीका):

// Declaration
int* myArray = 0;
int myArraySize = 0;

// Allocation (let's suppose size contains some value discovered at runtime,
// e.g. obtained from some external source)
if (myArray != 0) {
    myArray = (int*) realloc(myArray, size * sizeof(int));
} else {
    myArray = (int*) malloc(size * sizeof(int));
}

या (C ++ तरीका):

// Declaration
int* myArray = 0;
int myArraySize = 0;

// Allocation (let's suppose size contains some value discovered at runtime,
// e.g. obtained from some external source or through other program logic)
if (myArray != 0) {
    delete [] myArray;
}
myArray = new int [size];

ढेर विखंडन के साथ समस्याओं के बारे में अधिक जानकारी के लिए, आप इस प्रश्न का उल्लेख कर सकते हैं ।

Comments

1) ARRAY_SIZE = sizeof myArray / sizeof myArray[0];, इस तरह आप बग्स को पेश किए बिना myArray के प्रकार को बदल सकते हैं। उसी कारण से, myArray = realloc(myArray, size * sizeof *myArray);। BTW, malloc()या के वापसी मूल्य कास्टिंग realloc()भी बेकार है। 2) myArray != 0C वर्जन के लिए जाँच करना बेकार है, जैसा realloc(NULL, sz)कि इसके बराबर है malloc(sz)।

— एडगर बॉनेट

const int ARRAY_SIZE = 10; int myArray [ARRAY_SIZE]; क्या आपको लगता है कि यह संभव है? यह सी में variably संशोधित सरणी त्रुटि देना होगा

— अरुण जो Cheriyan

@ArunCheriyan CI में पता नहीं है, लेकिन C ++ में यह संकलन और पूरी तरह से चलता है। चूंकि Arduino C ++ आधारित है, इसलिए यहां कोई समस्या नहीं है।

— jfpoilpret

Answer 2

सरणी का आकार संकलन समय पर ज्ञात होना चाहिए। अन्यथा आपको गतिशील रूप से उपयोग करके मेमोरी आवंटित करनी चाहिए:

char *chararray = malloc(sizeof(char)*x);

जहाँ x (एक पूर्णांक) को अनुप्रयोग कोड में सेट किया जा सकता है (यदि आप इसे लगातार लेकिन विन्यास योग्य सेटिंग चाहते हैं तो इसे इप्रोम से लोड कर सकते हैं)।

---

हालाँकि यदि आप केवल एक ही आकार के कुछ ऐरे को घोषित करना चाहते हैं, तो आपको बस संख्या को इस तरह स्थिर घोषित करना होगा:

const int arrsize = 10;
char array1[arrsize];
int array2[arrsize];

---

मुझे लगता है कि चीजों को हार्डकोड नहीं करना केवल तभी समझ में आता है जब आप उपयोगकर्ता से किसी बिंदु पर सेटिंग में बदलाव करना चाहते हैं। मुझे नहीं पता कि क्या ऐसा है।

Comments

प्रतीकात्मक रूप से कोडिंग के आकार के बजाय शाब्दिक रूप से दो लाभ प्रदान कर सकते हैं: 1) एक अच्छी तरह से चुना गया प्रतीक दस्तावेज, या कम से कम सुझाव, पसंद का कारण; और 2) जब प्रोग्राम या मॉड्यूल के अन्य हिस्सों को उस पसंद के अनुरूप होना चाहिए, तो एक ही प्रतीक का उपयोग करके एक अभिव्यक्ति उस स्वचालित को बना सकती है, जिससे रखरखाव बहुत आसान हो जाएगा।

— JRobert

[थोड़ा सा विषय, लेकिन] "उपयोगकर्ता" अस्पष्ट है क्योंकि इसका मतलब कई लोगों में से एक हो सकता है। यह आम तौर पर अंतिम उपयोगकर्ता के उपभोक्ता का अर्थ है, यदि अन्यथा नहीं कहा गया है। यह अगला प्रोग्रामर हो सकता है, आपके कोड का तुरंत अगला उपभोक्ता, जो, वास्तव में, आप (मेरे खुद के अनुभव में) एक साल या उससे अधिक समय के बाद हो सकता है जब मैं इसके बारे में नॉटी-ग्रिट्टी आंतरिक विवरण भूल गया हूं)। या एक सिस्टम डिजाइनर जो अपने कोड को अपने उत्पाद में रेडी-टू-गो मॉड्यूल के रूप में शामिल करता है। मुझे संदेह है कि आपका दूसरा "उपयोगकर्ता" था।

— JRobert

Answer 3

यदि आप सरणी की अधिकतम लंबाई जानते हैं, तो बस उस लंबाई को सरणी को आरंभीकृत करें और एक पूर्णांक का उपयोग करके कार्यक्रम को बताएं कि उस सरणी का कितना उपयोग करना है। यदि यह 7,10 बाइट्स के बीच का अंतर है, तो आप उस मेमोरी आवंटन को बर्बाद नहीं कर रहे हैं।

Answer 4

मुझे पता है कि मैं यहाँ थोड़ी देर से हूँ, लेकिन सिद्धांत रूप में नियमित सरणियों को एक चर का उपयोग करके नहीं बनाया जा सकता है ताकि तत्वों की मात्रा को परिभाषित किया जा सके:

int arrSize;
int myArray[arrSize];

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

//First you create a pointer for the memory space to be separated for the set you're creating
int* myArray;
int arrSize; //Then you define the variable that will determine the amount of elements the array is going to have, you can give it a value whenever you want as long as this int is defined before the values in myArray are set 
myArray=(int*)calloc(arrSize,sizeof(int)) //Here, you establish that the instance myArray (whose memory space has already been separated through the creation of the pointer) will be separated into arrSize amount of elements of type int with a maximum memory value (in bytes) equal to the maximum available for the int type variables

इसके बाद, जो कुछ करना बाकी है, वह उदाहरण myArray (जो पहले से ही अब तक एक ऐरे है) में बनाए गए प्रत्येक तत्व के लिए एक मान निर्दिष्ट है जैसा कि आप myArray [arrSize] के रूप में बनाए गए सामान्य सरणी के लिए करेंगे।