स्ट्रिंग सरणी

Question

पर कचरा चरित्र के साथ स्ट्रिंग सरणी मेरे पास एक चार सरणी बफर है जिसका उपयोग मैं उन अक्षरों को संग्रहीत करने के लिए कर रहा हूं जो उपयोगकर्ता एक-एक करके इनपुट करेंगे। काम करता है नीचे दी गई मेरी कोड लेकिन कुछ खामियों है कि मैं समझ नहीं है:

1. जब मैं एक printf निष्पादित क्या बफर में है देखने के लिए, यह भरने करता है, लेकिन मैं अंत में कचरा पात्रों मिल
2. यह चार बफर [8] के रूप में घोषित किए जाने के बावजूद 8 वर्णों पर नहीं रुकेंगे;

क्या कोई मुझे बता सकता है कि क्या हो रहा है और शायद मैं इसे कैसे ठीक कर सकता हूं? धन्यवाद।

char Buffer[8]; //holds the byte stream 
int i=0; 

if (/* user input event has occurred */) 
{ 
     Buffer[i] = charInput; 
     i++; 

     // Display a response to input 
     printf("Buffer is %s!\n", Buffer); 

} 

आउटपुट:

 
tagBuffer is 1┬┬w! 
tagBuffer is 12┬w! 
tagBuffer is 123w! 
tagBuffer is 1234! 
tagBuffer is 12345! 
tagBuffer is 123456=! 
tagBuffer is 1234567! 
tagBuffer is 12345678!

tagBuffer 123456789 है!

Answer 1

आपको स्ट्रिंग को \ 0 वर्ण के साथ समाप्त करना होगा। यही कारण है कि उन्हें शून्य समाप्त तार कहा जाता है।

\ 0 को पकड़ने के लिए 1 अतिरिक्त चार आवंटित करना भी बुद्धिमानी है।

Answer 2

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

printf() और सभी मानक सी स्ट्रिंग फ़ंक्शन मानते हैं कि आपकी स्ट्रिंग के अंत में 0 है। printf() उदाहरण स्मृति में मुद्रण वर्ण रखेंगे, चार है कि आप कार्य करने के लिए पारित पर शुरू, जब तक यह हिट एक 0.

इसलिए आप कुछ इस तरह करने के लिए अपने कोड में परिवर्तन करना चाहिए के लिए:

char Buffer[9]; //holds the byte stream 
int i=0; 

if(//user input event has occured) 
{ 
     Buffer[i] = charInput; 
     i++; 

     Buffer[i] = 0; // You can also assign the char '\0' to it to get the same result. 

     // Display a response to input 
     printf("Buffer is %s!\n", Buffer); 

} 

Answer 3

यदि आप सी या सी ++ में प्रोग्रामिंग कर रहे हैं, तो आपको यह याद रखना होगा कि: 1) तारों को \ 0 वर्ण के साथ समाप्त कर दिया गया है। 2) सी तारों पर सीमा जांच नहीं है, वे सिर्फ चरित्र सरणी हैं।

Answer 4

आप stringstream का उपयोग करने के लिए भी देखना चाहते हैं।

Answer 5

शून्य समाप्ति के बारे में पिछली टिप्पणियों के अतिरिक्त, आपको अपने स्वयं के बफर को बहने की ज़िम्मेदारी भी स्वीकार नहीं करनी होगी। यह 8 अक्षरों पर नहीं रुकता है क्योंकि आपका कोड रोक नहीं रहा है!

#define DATA_LENGTH 8 
#define BUFFER_LENGTH (DATA_LENGTH + 1) 

char Buffer[BUFFER_LENGTH]; //holds the byte stream 
int charPos=0; //index to next character position to fill 

while (charPos <= DATA_LENGTH ) { //user input event has occured 
    Buffer[i] = charInput; 

    Buffer[i+1] = '\0'; 

    // Display a response to input 
    printf("Buffer is %s!\n", Buffer); 

    i++; 

} 

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

Answer 6

यह अजीब है कि कोई इस संभावना का उल्लेख किया गया है है:

char Buffer[8]; //holds the byte stream 
int i = 0; 

while (i < sizeof(Buffer) && (charInput = get_the_users_character()) != EOF) 
{ 
    Buffer[i] = charInput; 
    i++; 

    // Display a response to input 
    printf("Buffer is %.*s!\n", i, Buffer); 
} 

printf() प्रारूप स्ट्रिंग में इस टिप्पणी स्ट्रिंग की अधिकतम लंबाई प्रदर्शित करने के लिए निर्दिष्ट करता है, और अशक्त समाप्ति की आवश्यकता नहीं है (हालांकि अंततः समाप्त होने का सबसे अच्छा तरीका है - कम से कम एक बार जब आप इस लूप को छोड़ दें)।

while पाश एक सरल if की तुलना में अधिक विश्वसनीय है, और इस संस्करण सुनिश्चित करता है कि आप बफर के अंत अतिप्रवाह नहीं है (लेकिन यह सुनिश्चित नहीं है कि आप एक NUL '\0' अनुगामी के लिए पर्याप्त जगह छोड़ दें। आप को संभालने के लिए कि चाहते हैं , sizeof(Buffer) - 1 उपयोग करना और फिर पाश के बाद NUL जोड़ें।

Answer 7

Buffer के बाद से आरंभ नहीं किया जाता है, यह सभी 9 कचरा मूल्यों के साथ शुरू होता है। मनाया उत्पादन, 2nd, 3rd, 4, 5, 6, 7, 8 वीं से और 2 तत्काल अगली मेमोरी लोकेशन (सरणी के बाहर) तत्व स्पष्ट रूप से , 'T', 'W', '\0', '\0', '=', '\0', '\0', '\0'।

स्ट्रिंग सभी वर्णों को तब तक उपभोग करते हैं जब तक वे नल चरित्र नहीं देखते। यही कारण है कि, प्रत्येक पुनरावृत्ति में, जैसे सरणी तत्वों को एक-एक करके असाइन किया जाता है, बफर को उस भाग तक मुद्रित किया जाता है जहां एक कचरा न्यूल मौजूद होता है।

यह कहना है कि स्ट्रिंग का एक अनिर्धारित व्यवहार है यदि चरित्र सरणी '\0' के साथ समाप्त नहीं होती है। बफर के अंत में '\0' के लिए अतिरिक्त स्थान प्राप्त करके आप इससे बच सकते हैं।