सी में चरित्र सरणी की एक सरणी पर आप कैसे पुनरावृत्त करते हैं?

Question

क्या आपको एक बार सरणी के माध्यम से मैन्युअल रूप से लूप करना है और प्रत्येक वर्ण सरणी के स्ट्रेल की गिनती प्राप्त करना है, इसे समेटें, समेकित मूल्य के साथ गंतव्य आवंटित करें और फिर सरणी पर फिर से लूप करें?

आप सरणी के सरणी वाले सरणी का आकार कैसे प्राप्त करते हैं ताकि आप उन्हें फिर से चालू कर सकें?

Answer 1

आप सरणी कि पात्रों की सरणियों ताकि आप उन पर पुनरावृति कर सकते हैं के आकार कैसे पता करूं?

1. रिकार्ड सरणी है जब आप एक चर में यह आवंटन में तार की संख्या:

वहाँ दो तरीके हैं।

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

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

size_t sum_of_lengths(char const **a) 
{ 
    size_t i, total; 
    for (i = total = 0; a[i] != NULL; i++) 
     total += strlen(a[i]); 
    return total; 
} 

मत भूलना जब वास्तविक संयोजन कर एक '\0' के लिए स्थान आरक्षित करने के लिए तार के सरणी में वर्णों की कुल संख्या प्राप्त कर सकते हैं।

Answer 2

मुझे लगता है कि आप तारों को जोड़ना चाहते हैं। यदि हां, तो हाँ। आपको यह जानना होगा कि आप इसे आवंटित करने से पहले कितनी जगह चाहते हैं।

वास्तव में, आप realloc का उपयोग कर सकते हैं, लेकिन यह वास्तव में हर बार पिछली स्ट्रिंग की प्रतिलिपि बनाता है, और बहुत कम प्रभावी है।

कुछ कोड: (char *s[] और int n संभालने)

int i,l=1; 
for (i=0;i<n;i++) l+=strlen(s[i]); 
char *r=malloc(l); 
r[0]=0; 
for (i=0;i<n;i++) strcat(r,s[i]); 

संपादित करें: कुछ टिप्पणियों के रूप में, strcat जब आप लंबाई पता अप्रभावी है। (। मैं अभी भी इसे पसंद करते है, क्योंकि यह एक बार में स्मृति को आबंटित) कुछ और अधिक प्रभावी कोड है:

int i,l=1; 
for (i=0;i<n;i++) l+=strlen(s[i]); 
char *r=malloc(l); 
char *d=r; 
for (i=0;i<n;i++) { 
srtcpy(d,s[i]); 
d+=strlen(s[i]); 
} 

Answer 3

मैं तुम्हें एक स्ट्रिंग सरणी में तार के सभी के संयोजन है कि बनाने के लिए कोशिश कर रहे हैं मान।

ऐसा करने के 2 तरीके हैं:

1. 2 गुजरता बनाने का सुझाव के रूप में, दूसरा पास में, पहले पास में लंबाई संक्षेप गंतव्य स्ट्रिंग का आवंटन, और फिर जोड़कर तार

2. 1 पास करें। बफर को कुछ आकार में आवंटित करके प्रारंभ करें। कुल आकार का ट्रैक रखते हुए तारों को संलग्न करें। यदि आपके पास स्ट्रिंग के लिए पर्याप्त जगह नहीं है, तो realloc() के साथ बफर को पुन: आवंटित करें। पुनर्वितरण की सबसे प्रभावी विधि हर बार बफर के आकार को दोगुना करना होगा।

Answer 4

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

char *nstrdup(char **args); 
int main (int argc, char **argv) 
{ 
char * this; 

this = nstrdup(argv+1); 
printf("[%s]\n", this); 

return 0; 
} 

char *nstrdup(char **args) 
{ 
size_t len, pos; 
char **pp, *result; 

len = 0; 
for (pp = args; *pp; pp++) { 
     len += strlen (*pp); 
     } 
result = malloc (1+len); 

pos = 0; 
for (pp = args; *pp; pp++) { 
     len = strlen (*pp); 
     memcpy(result+pos, *pp, len); 
     pos += len; 
     } 
result[pos] = 0; 
return result; 
}