सी में एक चर की स्मृति सामग्री को मुद्रित करने के लिए कैसे?

Question

मैं एक

double d = 234.5; 

मैं d की स्मृति सामग्री [पूरे 8 बाइट्स]

मैं ऐसा कैसे करते देखना चाहते हो मान लीजिए?

Answer 1

double d = 234.5; 

/* 1. use a union */ 
union u { 
    double d; 
    unsigned char c[sizeof(double)]; 
}; 
union u tmp; 
size_t i; 
tmp.d = d; 
for (i=0; i < sizeof(double); ++i) 
    printf("%02x\n", tmp.c[i]); 

/* 2. memcpy */ 
unsigned char data[sizeof d]; 
size_t i; 
memcpy(data, &d, sizeof d); 
for (i=0; i < sizeof d; ++i) 
    printf("%02x\n", data[i]); 

/* 3. Use a pointer to an unsigned char to examine the bytes */ 
unsigned char *p = (unsigned char *)&d; 
size_t i; 
for (i=0; i < sizeof d; ++i) 
    printf("%02x\n", p[i]); 

सभी तरीकों आप बाइट्स — दिखाने लेकिन एक ही double मूल्य विभिन्न प्रणालियों, उदाहरण के लिए, विभिन्न एन्कोडिंग (दुर्लभ) की वजह से, या अलग endianness पर अलग ढंग से बाइट्स प्रिंट कर सकते हैं।

Answer 2

unsigned char *p = (unsigned char *)&d; 
int i; 

for (i = 0; i < sizeof d; i++) 
    printf("%02x ", p[i]); 

Answer 3

आप उस पते से शुरू d और प्रिंट sizeof(d) बाइट्स की पता लेने की कोशिश की?

Answer 4

union Plop 
{ 
    double value; 
    char  data[sizeof(double)]; 
}; 

Plop print; 
print.value = 234.5; 

std::copy(print.data,print.data+sizeof(double),std::ostream_iterator<int>(std::cout)," "); 
std::cout << std::endl; 

Answer 5

प्रयास करें आप gdb से देखने पर देख रहे हैं आप जारी कर सकते हैं:

x /gx d 

जी एक विशाल के रूप में मूल्य प्रिंट होगा (8 बाइट्स)

Answer 6

अपने दोस्ताना डीबगर का उपयोग स्मृति स्थान के मूल्य को देखने का सबसे अच्छा तरीका है, यह है कि यदि आप बस देखना चाहते हैं।

Answer 7

यदि आप बिट्स में डबल मान मुद्रित करना चाहते हैं तो इसे आजमाएं। मैंने फ्लोट वैल्यू के लिए प्रयास किया है। यदि आपने इसे बदल दिया है तो आप 64 बिट्स में डबल मान देखने में सक्षम हो सकते हैं। उपयोगी के टुकड़े के अपने पुस्तकालय की

#include <stdio.h> 

int main (void) 
{ 
     float f = 10.0f; 

     struct Float { 
       unsigned char bit01:1; 
       unsigned char bit02:1; 
       unsigned char bit03:1; 
       unsigned char bit04:1; 
       unsigned char bit05:1; 
       unsigned char bit06:1; 
       unsigned char bit07:1; 
       unsigned char bit08:1; 
       unsigned char bit09:1; 
       unsigned char bit10:1; 
       unsigned char bit11:1; 
       unsigned char bit12:1; 
       unsigned char bit13:1; 
       unsigned char bit14:1; 
       unsigned char bit15:1; 
       unsigned char bit16:1; 
       unsigned char bit17:1; 
       unsigned char bit18:1; 
       unsigned char bit19:1; 
       unsigned char bit20:1; 
       unsigned char bit21:1; 
       unsigned char bit22:1; 
       unsigned char bit23:1; 
       unsigned char bit24:1; 
       unsigned char bit25:1; 
       unsigned char bit26:1; 
       unsigned char bit27:1; 
       unsigned char bit28:1; 
       unsigned char bit29:1; 
       unsigned char bit30:1; 
       unsigned char bit31:1; 
       unsigned char bit32:1; 
     }; 

     struct Float *F; 

     F = (struct Float *) &f; 

     printf("\nMSB -->1 bit for sign bit; 8 bit for exponent; 23 bit for mantisa<-- LSB\n"); 
     printf("%d ", F->bit32); 
     printf("%d", F->bit31); 
     printf("%d", F->bit30); 
     printf("%d", F->bit29); 
     printf("%d", F->bit28); 
     printf("%d", F->bit27); 
     printf("%d", F->bit26); 
     printf("%d", F->bit25); 
     printf("%d ", F->bit24); 
     printf("%d", F->bit23); 
     printf("%d", F->bit22); 
     printf("%d", F->bit21); 
     printf("%d", F->bit20); 
     printf("%d", F->bit19); 
     printf("%d", F->bit18); 
     printf("%d", F->bit17); 
     printf("%d", F->bit16); 
     printf("%d", F->bit15); 
     printf("%d", F->bit14); 
     printf("%d", F->bit13); 
     printf("%d", F->bit12); 
     printf("%d", F->bit11); 
     printf("%d", F->bit10); 
     printf("%d", F->bit09); 
     printf("%d", F->bit08); 
     printf("%d", F->bit07); 
     printf("%d", F->bit06); 
     printf("%d", F->bit05); 
     printf("%d", F->bit04); 
     printf("%d", F->bit03); 
     printf("%d", F->bit02); 
     printf("%d\n", F->bit01); 
} 

Answer 8

सौजन्य, यहाँ परीक्षण दोहन के साथ सी में एक समाधान, पूरी हो चुकी है, और दोनों हेक्स और ASCII डेटा उपलब्ध कराने के:

#include <stdio.h> 

void hexDump (char *desc, void *addr, int len) { 
    int i; 
    unsigned char buff[17];  // stores the ASCII data 
    unsigned char *pc = addr;  // cast to make the code cleaner. 

    // Output description if given. 

    if (desc != NULL) 
     printf ("%s:\n", desc); 

    // Process every byte in the data. 

    for (i = 0; i < len; i++) { 
     // Multiple of 16 means new line (with line offset). 

     if ((i % 16) == 0) { 
      // Just don't print ASCII for the zeroth line. 

      if (i != 0) 
       printf (" %s\n", buff); 

      // Output the offset. 

      printf (" %04x ", i); 
     } 

     // Now the hex code for the specific character. 

     printf (" %02x", pc[i]); 

     // And store a printable ASCII character for later. 

     if ((pc[i] < 0x20) || (pc[i] > 0x7e)) 
      buff[i % 16] = '.'; 
     else 
      buff[i % 16] = pc[i]; 
     buff[(i % 16) + 1] = '\0'; 
    } 

    // Pad out last line if not exactly 16 characters. 

    while ((i % 16) != 0) { 
     printf (" "); 
     i++; 
    } 

    // And print the final ASCII bit. 

    printf (" %s\n", buff); 
} 

int main (int argc, char *argv[]) { 
    double d1 = 234.5; 
    char s1[] = "a 15char string"; 
    char s2[] = "This is a slightly longer string"; 
    hexDump ("d1", &d1, sizeof d1); 
    hexDump ("s1", &s1, sizeof s1); 
    hexDump ("s2", &s2, sizeof s2); 
    return 0; 
} 

अपने सिस्टम पर उत्पादन होता है:

d1: 
    0000 00 00 00 00 00 50 6d 40       .....Pm@ 
s1: 
    0000 61 20 31 35 63 68 61 72 20 73 74 72 69 6e 67 00 a 15char string. 
s2: 
    0000 54 68 69 73 20 69 73 20 61 20 73 6c 69 67 68 74 This is a slight 
    0010 6c 79 20 6c 6f 6e 67 65 72 20 73 74 72 69 6e 67 ly longer string 
    0020 00            . 

---

के बाद से इस सवाल का टैग है सी ++ भी, यहाँ तुलना करने के लिए एक iostream संस्करण है। भले ही आप iostreams का एक विशेष प्रशंसक नहीं हैं, फिर भी यदि आप पहले से ही उनका उपयोग कर रहे हैं तो यह अभी भी फिट बैठता है। hexdump(any_obj) का उपयोग करने में सक्षम होने के नाते भी अच्छा है, लेकिन निश्चित रूप से सीटीओआर के समान एक प्रतिनिधि समारोह टेम्पलेट के साथ किया जा सकता है।

#include <iomanip> 
#include <ostream> 
#include <string> 

struct hexdump { 
    void const* data; 
    int len; 

    hexdump(void const* data, int len) : data(data), len(len) {} 

    template<class T> 
    hexdump(T const& v) : data(&v), len(sizeof v) {} 

    friend 
    std::ostream& operator<<(std::ostream& s, hexdump const& v) { 
    // don't change formatting for s 
    std::ostream out (s.rdbuf()); 
    out << std::hex << std::setfill('0'); 

    unsigned char const* pc = reinterpret_cast<unsigned char const*>(v.data); 

    std::string buf; 
    buf.reserve(17); // premature optimization 

    int i; 
    for (i = 0; i < v.len; ++i, ++pc) { 
     if ((i % 16) == 0) { 
     if (i) { 
      out << " " << buf << '\n'; 
      buf.clear(); 
     } 
     out << " " << std::setw(4) << i << ' '; 
     } 

     out << ' ' << std::setw(2) << unsigned(*pc); 
     buf += (0x20 <= *pc && *pc <= 0x7e) ? *pc : '.'; 
    } 
    if (i % 16) { 
     char const* spaces16x3 = "            "; 
     out << &spaces16x3[3 * (i % 16)]; 
    } 
    out << " " << buf << '\n'; 

    return s; 
    } 
}; 

int main() { 
    std::cout << "double:\n" << hexdump(234.5); 
    std::cout << "string 1:\n" << hexdump("a 15char string"); 
    std::cout << "string 2:\n" << hexdump("This is a slightly longer string"); 

    return 0; 
} 

Answer 9

मुझे लगता है कि आप वास्तविक बिट्स को "मास्क आउट" करने के लिए शिफ्ट ऑपरेशन और मास्क का उपयोग कर सकते हैं।

पूर्णांक टी = 128;

के लिए (int i = 0; मैं < 8; ++ i) { printf ("% d", पी & टी);

पी = >> 1;

टी = >> 1; }