खराब प्रदर्शन के कारण जब तार श्रृंखलाबद्ध स्मृति के पुनः आबंटन है। जोएल स्पॉस्की ने अपने लेख Back to basics में इस पर चर्चा की। उन्होंने श्रृंखलाबद्ध तार के अनुभवहीन विधि का वर्णन करता है:
Shlemiel में एक सड़क का चित्रकार की नौकरी मिल जाती, सड़क के बीच नीचे बिंदु वाली रेखा चित्र। पहले दिन वह सड़क पर पेंट करने का एक तरीका लेता है और सड़क के 300 गज की दूरी तय करता है। "वह बहुत बढिया है!" अपने मालिक कहते हैं, "आप एक तेज कार्यकर्ता हैं!" और उसे एक कोपेक देता है।
अगले दिन शलेमिल केवल 150 गज की दूरी पर हो जाता है। "ठीक है, यह कल के रूप में लगभग उतना अच्छा नहीं है, लेकिन आप अभी भी एक तेज कार्यकर्ता हैं। 150 गज सम्मानजनक है," और उसे एक कोपेक देता है।
अगले दिन शलेमेल सड़क के 30 गज की दूरी पर चित्रित करता है। "केवल 30!" अपने मालिक को चिल्लाता है। "यह अस्वीकार्य है! पहले दिन आपने दस गुना इतना काम किया था! क्या चल रहा है?" श्लेमीएल कहते हैं,
"मैं इसकी मदद नहीं कर सकता"। "हर दिन मैं पेंट से दूर और दूर हो सकता है!"
यदि आप कर सकते हैं, तो आप जानना चाहते हैं कि आपके गंतव्य बफर को आवंटित करने से पहले कितना बड़ा होना चाहिए। ऐसा करने का एकमात्र यथार्थवादी तरीका उन सभी तारों पर strlen पर कॉल करना है जिन्हें आप जोड़ना चाहते हैं। फिर उचित मात्रा में स्मृति आवंटित करें और strncpy के थोड़ा संशोधित संस्करण का उपयोग करें जो गंतव्य बफर के अंत में पॉइंटर लौटाता है।
// Copies src to dest and returns a pointer to the next available
// character in the dest buffer.
// Ensures that a null terminator is at the end of dest. If
// src is larger than size then size - 1 bytes are copied
char* StringCopyEnd(char* dest, char* src, size_t size)
{
size_t pos = 0;
if (size == 0) return dest;
while (pos < size - 1 && *src)
{
*dest = *src;
++dest;
++src;
++pos;
}
*dest = '\0';
return dest;
}
नोट आप कैसे बाइट्स गंतव्य बफर के अंत तक छोड़ दिया की संख्या होने के लिए size पैरामीटर सेट करना होगा।
void testStringCopyEnd(char* str1, char* str2, size_t size)
{
// Create an oversized buffer and fill it with A's so that
// if a string is not null terminated it will be obvious.
char* dest = (char*) malloc(size + 10);
memset(dest, 'A', size + 10);
char* end = StringCopyEnd(dest, str1, size);
end = StringCopyEnd(end, str2, size - (end - dest));
printf("length: %d - '%s'\n", strlen(dest), dest);
}
int main(int argc, _TCHAR* argv[])
{
// Test with a large enough buffer size to concatenate 'Hello World'.
// and then reduce the buffer size from there
for (int i = 12; i > 0; --i)
{
testStringCopyEnd("Hello", " World", i);
}
return 0;
}
कौन सा पैदा करता है:
length: 11 - 'Hello World'
length: 10 - 'Hello Worl'
length: 9 - 'Hello Wor'
length: 8 - 'Hello Wo'
length: 7 - 'Hello W'
length: 6 - 'Hello '
length: 5 - 'Hello'
length: 4 - 'Hell'
length: 3 - 'Hel'
length: 2 - 'He'
length: 1 - 'H'
length: 0 - ''
आप सख्ती से सी का उपयोग कर रहे
यहां नमूने के परीक्षण समारोह है? या आप सी ++ का भी उपयोग कर सकते हैं? – Nico
ठीक है आप उन्हें sprintf() कॉल के समूह में जोड़ सकते हैं। बस वापसी मूल्य का उपयोग करें ... – wildplasser
@ निको मैं सादा सी का उपयोग कर रहा हूं, और मैं सी ++ से बचना चाहता हूं। –