लगातार स्ट्रिंग सरणी

Question

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

typedef struct { 
     int len; 
     int pos[100]; 
     char data[500]; 
} FixedStringArray; 

const FixedStringArray items = { 
     4, 
     { 9, 14, 19, 24 }, 
     "LongWord1Word2Word3Word4" 
} ; 

char* GetItem(FixedStringArray *array, int idx, int *len) { 
     if (idx >= array->len) { 
       /* Out of range */ 
       *len = -1; 
       return NULL; 
     } 

     if (idx > 0) { 
       *len = array->pos[idx] - array->pos[idx - 1]; 
       return & array->data[array->pos[idx - 1]]; 
     } 

     *len = array->pos[idx]; 
     return & array->data[0]; 
} 

void PrintItem(FixedStringArray array, int idx) { 
     int len; 
     char *c; 
     int i = 0; 

     c = GetItem(&array, idx, &len); 

     if (len == -1) return; 

     while (i < len) { 
       printf("%c", *c); 
       *c++; 
       i++; 
     } 
} 

मैं एक स्क्रिप्ट है कि स्वचालित रूप से प्रत्येक सरणी के लिए एक struct उत्पन्न करता है और स्थिति और डेटा के लिए सही लंबाई का उपयोग करता पर विचार कर रहा हूँ। क्या स्मृति उपयोग के मामले में कोई चिंता है? या सभी तारों को फिट करने के लिए एक संरचना (ऊपर की तरह) बनाने के लिए बेहतर होगा?

Answer 1

क्या आपका सी कंपाइलर रीड-ओनली मेमोरी (जैसे स्ट्रिंग पूलिंग सक्षम के साथ वीसी ++) में किसी भी/सभी शाब्दिक तारों को चिपका सकता है? या क्या आप स्पष्ट रूप से उन्हें इस तरह अनुक्रमित रूप से संग्रहीत करने की आवश्यकता है?

Answer 2

मुझे यकीन है कि मैं अपने प्रश्न समझ में नहीं हूँ, लेकिन आप क्या मतलब है:

const char * const array[] = { "LongWord1", "Word2", "Word3", "Word4" }; 

यह लगातार वर्ण की ओर इशारा की एक निरंतर सरणी की घोषणा की।

ठीक है, strlen से बचने के लिए, कैसे के बारे में:

struct Str { 
    size_t len; 
    char *str; 
}; 
#define STR(s) { sizeof(#s) - 1, #s } 
const struct Str[] = { STR(LongWord1), STR(Word2), STR(Word3), STR(Word4) }; 

Answer 3

यह सवाल कुछ हद तक प्रासंगिक है:
String Literals

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