प्रिंटफ () हेक्स के लिए स्वरूपण

Question

यह एक महत्वपूर्ण प्रश्न की तुलना में अधिक जिज्ञासु प्रश्न है, लेकिन जब शीर्ष शून्य के साथ 8 अंकों की संख्या के रूप में हेक्स को प्रिंट करते हैं, तो क्या यह %#08Xउसी परिणाम को प्रदर्शित नहीं करता है 0x%08X?

जब मैं पूर्व का उपयोग करने की कोशिश करता हूं, तो 08स्वरूपण ध्वज हटा दिया जाता है, और यह सिर्फ साथ काम नहीं करता है 8।

फिर से मैं बस उत्सुक था।

Comments

क्या आपका मतलब है 0x%.8X? जो कि जीरो से लीड-फिल करेगा । ( 0xयह सिर्फ एक प्रस्तावना है, लेकिन आपकी संभावना पहले से ही इसके बारे में पता है)।

— WhoCCraig

Answer 1

#भाग आप एक देता है 0xउत्पादन स्ट्रिंग में। 0और xअपने "8" में सूचीबद्ध वर्णों के खिलाफ गिनती 08हिस्सा। यदि आप चाहते हैं कि आप 10 वर्णों के लिए पूछना चाहते हैं।

int i = 7;

printf("%#010x\n", i);  // gives 0x00000007
printf("0x%08x\n", i);  // gives 0x00000007
printf("%#08x\n", i);   // gives 0x000007

के मामले को भी बदल रहा है x, आउटपुट वर्णों के आवरण को प्रभावित करता है।

printf("%04x", 4779); // gives 12ab
printf("%04X", 4779); // gives 12AB

Comments

शीर्ष पंक्ति मेरे लिए 14F0x00000007 का उत्पादन करती है। लिखित के रूप में दूसरा और तीसरा काम।

— क्वांटम्पोटेटो

@quantumpotato - यह अजीब है। पहली और तीसरी लाइनें 0 की संख्या के अपवाद के साथ समान हैं जो उन्हें उत्पन्न करनी चाहिए। आपका संकलक / सिस्टम / कोड ऑफ़ लाइन क्या था जिसने इसे बनाया है? क्या आपके पास कोई रेखा है जो मुद्रित की गई है 14F?

— माइक

ध्यान दें कि यदि i = 0;, उपयोग करने वाले संस्करणों %#में 0xउपसर्ग शामिल नहीं होगा ।

— जोनाथन लेफलर

लेकिन हेक्स के बारे में कैसे: 0x43A66C31C68491C0 मैंने निम्नलिखित कोशिश की है: __int64 int64 = 0x43A66C31C68491C0; Printf_s ("% # 15X% d", int64, int64); लेकिन आउटपुट 0XC68491C0 है, न कि 0x43A66C31C68491C0

— 123iamking

ऊपर हेक्स 0x43A66C31C68491C0 के बारे में, मैंने इसे हल किया है, समाधान 0x% I64X है,% # 15X नहीं

— 123iamking

Answer 2

"0x" आठ वर्ण गणना की ओर गिना जाता है। आपको चाहिए "%#010x"।

ध्यान दें कि #है नहीं 0 0x संलग्न - परिणाम होगा 0000000000- तो आप शायद वास्तव में सिर्फ इस्तेमाल करना चाहिए "0x%08x"वैसे भी।

Answer 3

%#08Xरूपांतरण के साथ मूल्य पूर्व में होना चाहिए 0X; यह मानक द्वारा आवश्यक है। मानक में कोई सबूत नहीं है कि विनिर्देश #के 08हिस्से के व्यवहार को बदलना चाहिए सिवाय इसके कि 0Xउपसर्ग को लंबाई के हिस्से के रूप में गिना जाता है (इसलिए आप उपयोग करना चाहते हैं / उपयोग करने की आवश्यकता हो सकती है %#010X। यदि, मेरी तरह, तो आप अपने हेक्स की तरह प्रस्तुत करते हैं। 0x1234CDEF, तब आपको 0x%08Xवांछित परिणाम प्राप्त करने के लिए उपयोग करना होगा। आप उपयोग कर सकते हैं %#.8Xऔर इसमें अग्रणी जीरो भी सम्मिलित करना चाहिए।

निम्नलिखित कोड पर बदलाव का प्रयास करें:

#include <stdio.h>

int main(void)
{
    int j = 0;
    printf("0x%.8X = %#08X = %#.8X = %#010x\n", j, j, j, j);
    for (int i = 0; i < 8; i++)
    {
        j = (j << 4) | (i + 6);
        printf("0x%.8X = %#08X = %#.8X = %#010x\n", j, j, j, j);
    }
    return(0);
}

एक RHEL 5 मशीन पर, और मैक ओएस एक्स (10.7.5) पर भी, आउटपुट था:

0x00000000 = 00000000 = 00000000 = 0000000000
0x00000006 = 0X000006 = 0X00000006 = 0x00000006
0x00000067 = 0X000067 = 0X00000067 = 0x00000067
0x00000678 = 0X000678 = 0X00000678 = 0x00000678
0x00006789 = 0X006789 = 0X00006789 = 0x00006789
0x0006789A = 0X06789A = 0X0006789A = 0x0006789a
0x006789AB = 0X6789AB = 0X006789AB = 0x006789ab
0x06789ABC = 0X6789ABC = 0X06789ABC = 0x06789abc
0x6789ABCD = 0X6789ABCD = 0X6789ABCD = 0x6789abcd

मैं 0 के उपचार पर थोड़ा हैरान हूं; मैं स्पष्ट नहीं हूं कि 0Xउपसर्ग क्यों छोड़ा गया है, लेकिन दो अलग-अलग प्रणालियों को करने के साथ, यह मानक होना चाहिए। यह #विकल्प के खिलाफ मेरे पूर्वाग्रहों की पुष्टि करता है।

---

शून्य का उपचार मानक के अनुसार है।

आईएसओ / आईईसी 9899: 2011 §7.21.6.1 समारोहfprintf

¶6 ध्वज अक्षर और उनके अर्थ हैं:
...
#परिणाम "वैकल्पिक रूप" में परिवर्तित हो जाता है। ... रूपांतरण x(या X) रूपांतरण के लिए, एक नॉनज़रो परिणाम में 0x(या 0X) इसके लिए उपसर्ग होता है। ...

(महत्व दिया।)

---

ध्यान दें कि उपयोग %#Xकरने से हेक्स अंकों के लिए और 0Xउपसर्ग के रूप में ऊपरी-केस अक्षरों का उपयोग किया जाएगा ; उपयोग %#xकरने से हेक्स अंकों के लिए और 0xउपसर्ग के रूप में कम-केस अक्षरों का उपयोग किया जाएगा । यदि आप 0xउपसर्ग और ऊपरी-केस अक्षरों के रूप में पसंद करते हैं , तो आपको 0xअलग से कोड करना होगा 0x%X:। अन्य प्रारूप संशोधक, आवश्यकतानुसार जोड़े जा सकते हैं।

मुद्रण पते के लिए, <inttypes.h>शीर्ष लेख और uintptr_tप्रकार और PRIXPTRप्रारूप मैक्रो का उपयोग करें:

#include <inttypes.h>
#include <stdio.h>

int main(void)
{
    void *address = &address;  // &address has type void ** but it converts to void *
    printf("Address 0x%.12" PRIXPTR "\n", (uintptr_t)address);
    return 0;
}

उदाहरण आउटपुट:

Address 0x7FFEE5B29428

लंबाई पर अपना जहर चुनें - मुझे लगता है कि मैक पर चलने वाले मैकओएस पर पतों के लिए 12 की परिशुद्धता अच्छी तरह से काम करती है। .न्यूनतम सटीकता (अंकों) को निर्दिष्ट करने के लिए संयुक्त , यह प्रारूपों को मज़बूती से संबोधित करता है। यदि आप 16 पर सटीक सेट करते हैं, तो मैक पर मेरे अनुभव में अतिरिक्त 4 अंक हमेशा 0 होते हैं, लेकिन पोर्टेबल 64-बिट कोड में 12 के बजाय 16 का उपयोग करने के लिए निश्चित रूप से एक मामला है (लेकिन आप 8 का उपयोग करेंगे) 32-बिट कोड)।