सी स्ट्रिंग में वर्णों को उनके भागने के दृश्यों में कनवर्ट करें

Question

मुझे स्ट्रिंग ToLiteral (स्ट्रिंग इनपुट)this post से फ़ंक्शन की आवश्यकता है। इस तरह की है कि

char *literal = to_literal("asdf\r\n"); 

उपज हैं शाब्दिक ==> "asdf \\ r \\ n"।

मैंने चारों ओर गुगल किया है, लेकिन कुछ भी नहीं ढूंढ पाया (अनुमान है कि मुझे गलत शर्तों का उपयोग करना होगा)। हालांकि, मुझे लगता है कि इस कार्यक्षमता वाला एक पुस्तकालय कहीं बाहर होना चाहिए ...

इंटरस्टेस्टिंग उत्तरों के लिए धन्यवाद। गुगलिंग "सी स्ट्रिंग एस्केप फ़ंक्शन" और भी उदाहरण प्राप्त करने की कुंजी प्रतीत होता है और जीएलआईबी g_strescape() प्रदान करता है जो मुझे बिल्कुल वही लगता है जो मुझे चाहिए।

Answer 1

की तरह कुछ इस के लिए कोई अंतर्निहित समारोह है हो सकता है, लेकिन आप कर सकते थे कोड़ा एक अप:

/* Expands escape sequences within a C-string 
* 
* src must be a C-string with a NUL terminator 
* 
* dest should be long enough to store the resulting expanded 
* string. A string of size 2 * strlen(src) + 1 will always be sufficient 
* 
* NUL characters are not expanded to \0 (otherwise how would we know when 
* the input string ends?) 
*/ 

void expand_escapes(char* dest, const char* src) 
{ 
    char c; 

    while (c = *(src++)) { 
    switch(c) { 
     case '\a': 
     *(dest++) = '\\'; 
     *(dest++) = 'a'; 
     break; 
     case '\b': 
     *(dest++) = '\\'; 
     *(dest++) = 'b'; 
     break; 
     case '\t': 
     *(dest++) = '\\'; 
     *(dest++) = 't'; 
     break; 
     case '\n': 
     *(dest++) = '\\'; 
     *(dest++) = 'n'; 
     break; 
     case '\v': 
     *(dest++) = '\\'; 
     *(dest++) = 'v'; 
     break; 
     case '\f': 
     *(dest++) = '\\'; 
     *(dest++) = 'f'; 
     break; 
     case '\r': 
     *(dest++) = '\\'; 
     *(dest++) = 'r'; 
     break; 
     case '\\': 
     *(dest++) = '\\'; 
     *(dest++) = '\\'; 
     break; 
     case '\"': 
     *(dest++) = '\\'; 
     *(dest++) = '\"'; 
     break; 
     default: 
     *(dest++) = c; 
    } 
    } 

    *dest = '\0'; /* Ensure nul terminator */ 
} 

ध्यान दें कि मैं (कुछ compilers \e का उपयोग करें और दूसरों \x का उपयोग करें) "भागने" चरित्र को पलायन अनुक्रम का अनुवाद बाहर छोड़ दिया गया है, के बाद से इस सी में मानकीकृत नहीं है। जो भी आप पर लागू होता है उसमें आप जोड़ सकते हैं।

आप एक समारोह है कि आप के लिए अपने गंतव्य बफर आवंटित करना चाहते हैं:

/* Returned buffer may be up to twice as large as necessary */ 
char* expand_escapes_alloc(const char* src) 
{ 
    char* dest = malloc(2 * strlen(src) + 1); 
    expand_escapes(dest, src); 
    return dest; 
} 

Answer 2

मुझे लगता है कि आप शब्दावली भ्रमित कर रहे हैं, तो आप इस तरह चार करने के लिए (Acter) एक सूचक को प्रारंभ कर सकते हैं:

char *literal = "asdf\r\n" 

संशोधन: हालांकि, सी स्ट्रिंग्स उदाहरण के लिए भागने उद्धरण उपयोग करने में सक्षम हैं:

char *literal = "\basdf\x1b\r\n\v\t"; 

बाहर प्रिंट होगा कि

<backspace>asdf<escape-character><carriage-return><linefeed><vertical-tab><tab> 

उन पात्रों को कंसोल क्षमताओं के आधार पर नहीं दिखाया जाएगा, आप भागने के लिए एक तीर और टैब के लिए एक अंतर देख सकते हैं ... आप प्रत्येक \ के लिए एक साधारण तर्क का उपयोग करके इसे प्राप्त कर सकते हैं, \ डालें ऐसी है कि वह प्रदर्शित करेगा

asdf\\r\\n 

कुछ निम्न कोड की तरह पर्याप्त होना चाहिए:

void ToLiteral(const char *pStr){ 
    char *p = (char*)pStr; 
    while (*p){ 
     /* if (*p == '\\') putchar('\\'); */ 
     /* PERFORM THE LOOK UP */ 
     putchar(*p++); 
    } 
} 

लेकिन इसे देख, यह सही महसूस नहीं किया था के रूप में सूचक वास्तविक \n और \r तो यह हो सकता है पकड़ रखी थी एक लू का उपयोग करना आसान हो k-अप तालिका भागने दृश्यों के लिए वास्तविक हेक्साडेसिमल कोड तुलना और उचित कोड प्रदर्शित करने के लिए ... लुकअप तालिका इस

struct LookUp{ 
    int codeLiteral; 
    char *equivCodeLiteral; 
}; 

struct LookUp look[] = { { 0xa, "\\r"}, { 0xd, "\\n" }, { 0x9, "\\t" } }; 

Answer 3

मुझे लगता है कि मैं इस तरह रूपांतरण कुछ करना चाहते हैं:

// warning: untested code. 
void make_literal(char const *input, char *output) { 
    // the following two arrays must be maintained in matching order: 
    static char inputs[] = "\a\b\f\n\r\t\v\\\"\'"; 
    static char outputs[] = "abfnrtv\\\"\'"; 

    char *p, *pos; 

    for (;*input;input++) { 
     if (NULL!= (pos=strchr(inputs, *input))) { 
      *output++ = '\\'; 
      *output++ = outputs[pos-inputs]; 
     } 
     else 
      *output++ = *input; 
    } 
    *output = '\0'; 
} 

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