मैंने यह फ़ंक्शन लिखा है जो StringPadRight ("Hello", 10, "0") -> "Hello00000" करने वाला है।
char *StringPadRight(char *string, int padded_len, char *pad) {
int len = (int) strlen(string);
if (len >= padded_len) {
return string;
}
int i;
for (i = 0; i < padded_len - len; i++) {
strcat(string, pad);
}
return string;
}
यह काम करता है लेकिन कुछ अजीब दुष्प्रभाव हैं ... कुछ अन्य चर बदल जाते हैं। मैं इसे कैसे ठीक करूं?
जवाबों:
यह जानना उपयोगी हो सकता है कि प्रिंटफ आपके लिए पैडिंग करता है,% -10 का उपयोग करते हुए प्रारूप स्ट्रिंग के रूप में एक क्षेत्र में वर्णों को सही ढंग से पैड करेगा 10 वर्ण लंबे
printf("|%-10s|", "Hello");
उत्पादन होगा
|Hello |
इस मामले में - प्रतीक का अर्थ है "वाम गठबंधन", 10 का अर्थ है "क्षेत्र में दस वर्ण" और एस का अर्थ है कि आप एक स्ट्रिंग संरेखित कर रहे हैं।
प्रिंटफ शैली प्रारूपण कई भाषाओं में उपलब्ध है और वेब पर इसके बहुत सारे संदर्भ हैं। यहाँ कई पृष्ठों में से एक है जो प्रारूपण झंडे की व्याख्या करता है। हमेशा की तरह विकीपीडिया का प्रिंटफ़ पेज भी बहुत मदद करता है (ज्यादातर इस बात का एक इतिहास सबक है कि व्यापक रूप से प्रिंटफ़ का प्रसार कैसे हुआ)।
printfऐसी विशेषताओं का कोई संकेत नहीं लगता है।)
printfहूबहू नहीं तो ज्यादातर एक ही व्यवहार करना चाहिए, इस है सी, सी ++ नहीं।
'सी' के लिए [s] प्रिंटफ का वैकल्पिक (अधिक जटिल) उपयोग है जिसे कस्टम पैडिंग के लिए वांछित होने पर किसी भी मॉलोक () या पूर्व-स्वरूपण की आवश्यकता नहीं होती है।
यह चाल% s के लिए '*' लंबाई के विनिर्देशक (न्यूनतम और अधिकतम) का उपयोग करना है, साथ ही अधिकतम संभावित लंबाई के लिए आपके पैडिंग चरित्र से भरा एक स्ट्रिंग है।
int targetStrLen = 10; // Target output length
const char *myString="Monkey"; // String for output
const char *padding="#####################################################";
int padLen = targetStrLen - strlen(myString); // Calc Padding length
if(padLen < 0) padLen = 0; // Avoid negative length
printf("[%*.*s%s]", padLen, padLen, padding, myString); // LEFT Padding
printf("[%s%*.*s]", myString, padLen, padLen, padding); // RIGHT Padding
"% *। * S" को आपके "% s" के पहले या बाद में LEFT या RIGHT पैडिंग की इच्छा के आधार पर रखा जा सकता है।
[####Monkey] <-- Left padded, "%*.*s%s"
[Monkey####] <-- Right padded, "%s%*.*s"
मैंने पाया कि PHP प्रिंटफ ( यहाँ ) % s फॉर्मेट के भीतर अपने कस्टम पैडिंग कैरेक्टर के बाद सिंगल कोटे (') का उपयोग करके एक कस्टम पैडिंग कैरेक्टर देने की क्षमता का समर्थन करता है ।
printf("[%'#10s]\n", $s); // use the custom padding character '#'
उत्पादन:
[####monkey]
आपको यह सुनिश्चित करना चाहिए कि इनपुट स्ट्रिंग में सभी पेडिंग वर्ण रखने के लिए पर्याप्त स्थान है। इसे इस्तेमाल करे:
char hello[11] = "Hello";
StringPadRight(hello, 10, "0");
ध्यान दें कि मैंने helloस्ट्रिंग के लिए अंत में अशक्त टर्मिनेटर के लिए 11 बाइट आवंटित किए ।
"हैलो" पास किया गया तर्क निरंतर डेटा क्षेत्र पर है। जब तक आपने char * string को पर्याप्त मेमोरी आवंटित नहीं की है, तब तक यह अन्य वेरिएबल्स के लिए अतिरंजित है।
char buffer[1024];
memset(buffer, 0, sizeof(buffer));
strncpy(buffer, "Hello", sizeof(buffer));
StringPadRight(buffer, 10, "0");
संपादित करें: स्टैक से निरंतर डेटा क्षेत्र में ठीक किया गया।
ओह ठीक है, समझ में आता है। तो मैंने ऐसा किया:
char foo[10] = "hello";
char padded[16];
strcpy(padded, foo);
printf("%s", StringPadRight(padded, 15, " "));
धन्यवाद!
#include <iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
using namespace std;
int main() {
// your code goes here
int pi_length=11; //Total length
char *str1;
const char *padding="0000000000000000000000000000000000000000";
const char *myString="Monkey";
int padLen = pi_length - strlen(myString); //length of padding to apply
if(padLen < 0) padLen = 0;
str1= (char *)malloc(100*sizeof(char));
sprintf(str1,"%*.*s%s", padLen, padLen, padding, myString);
printf("%s --> %d \n",str1,strlen(str1));
return 0;
}
#include <stdio.h>
#include <string.h>
int main(void) {
char buf[BUFSIZ] = { 0 };
char str[] = "Hello";
char fill = '#';
int width = 20; /* or whatever you need but less than BUFSIZ ;) */
printf("%s%s\n", (char*)memset(buf, fill, width - strlen(str)), str);
return 0;
}
आउटपुट:
$ gcc -Wall -ansi -pedantic padding.c
$ ./a.out
###############Hello
फंक्शन ही मुझे ठीक लग रहा है। समस्या यह हो सकती है कि आप अपने स्ट्रिंग को पैड के लिए पर्याप्त स्थान आवंटित नहीं कर रहे हैं कि उस पर कई अक्षर। आप size_of_stringफ़ंक्शन के लिए एक तर्क पास करके भविष्य में इस समस्या से बच सकते हैं और सुनिश्चित करें कि आप स्ट्रिंग को पैड नहीं करते हैं जब लंबाई आकार से अधिक होने वाली है।
इस थ्रेड में मूल प्रश्न बनाने वाले फ़ंक्शन में एक चीज निश्चित रूप से गलत है, जिसे मैंने किसी का उल्लेख नहीं देखा है, वह यह है कि यह स्ट्रिंग अक्षर के अंत में अतिरिक्त वर्णों को समाप्त कर रहा है जिसे एक पैरामीटर के रूप में पारित किया गया है। यह अप्रत्याशित परिणाम देगा। फ़ंक्शन के उदाहरण कॉल में, स्ट्रिंग शाब्दिक "हैलो" को प्रोग्राम में हार्ड-कोड किया जाएगा, इसलिए संभवतः इसके अंत में संक्षिप्त रूप से कोड पर खतरनाक रूप से लिखना होगा। यदि आप एक स्ट्रिंग वापस करना चाहते हैं जो मूल से बड़ा है तो आपको यह सुनिश्चित करने की आवश्यकता है कि आप इसे गतिशील रूप से आवंटित करें और जब आप काम कर रहे हों तो इसे कॉलिंग कोड में हटा दें।
#include<stdio.h>
#include <string.h>
void padLeft(int length, char pad, char* inStr,char* outStr) {
int minLength = length * sizeof(char);
if (minLength < sizeof(outStr)) {
return;
}
int padLen = length - strlen(inStr);
padLen = padLen < 0 ? 0 : padLen;
memset(outStr, 0, sizeof(outStr));
memset(outStr, pad,padLen);
memcpy(outStr+padLen, inStr, minLength - padLen);
}