fork download 
  1. #include <stdio.h>
  2. #define loctype long
  3. //#define loctype short
  4. //#define loctype double
  5. //#define loctype float
  6. #define value 3735928559 //a fun value which turns into DEADBEEF in hex.
  7. #define EOL 13
  8.  
  9. //Normally, of course, you would just printf in hex format:
  10. // printf("%04X", value); //replace 04 with sizeof(value)
  11. //But printf is ungodly huge and slow. If you need something tiny and faster...
  12.  
  13.  
  14. char hexnibblea (unsigned char b) {
  15. 	if (b>9) b+=('A'-10); else b+='0';
  16. 	return b;
  17. 	}
  18. /* A good C compiler should generate something like
  19.  
  20.  LOAD b
  21.  SUB #9
  22.  LOAD #55 ; 'A'-10
  23.  SKIP ABOVEZERO
  24.  LOAD #48 ; '0'
  25.  ADD b
  26.  SAVE b
  27.  
  28.  You don't want to know what they really generate. *facepalm*
  29. */
  30.  
  31. //if you don't mind wasting some program memory:
  32. #define hexnibble_m(b) "0123456789ABCDEF"[b]
  33. // or if you will use it more than once:
  34. char hexnibble (unsigned char b) {
  35. 	return hexnibble_m(b);
  36. 	}
  37.  
  38. void puts_hex_r(loctype h) { //type* & order agnostic, lsb first output
  39. 	char i;
  40. 	for (i = sizeof(loctype)*2-1; i>=0; i--) { //down count is faster
  41. 		putchar(hexnibble((unsigned char)h&0xF));
  42. 		h/=16; // easily optimized by most compilers
  43. 		}
  44. 	putchar(EOL);
  45. 	}
  46.  
  47. //the only problem with the above is that it is lsb first. And, as Aram notes:
  48. //"a byte (8 bit value), does not have endianness so you do not reverse the nibbles. 
  49. // The correct output should be EFBEADDE00000000."
  50. //Since our goal here is just to move data over an ASCII channel, we can ignore 
  51. //the byte order reversal. 
  52.  
  53. //If you want msb first, and you have memory for a buffer: 
  54. //https://stackoverflow.com/a/36968534/663416 
  55. //otherwise...
  56. //Note: the following code is horrific. pointers, order dependant, fails for floats.
  57. void puts_hex_f(loctype h) {
  58. 	char i;
  59. 	unsigned char n;
  60. 	unsigned char  *p = (unsigned char *)&h+sizeof(loctype)-1;
  61. 	for (i = sizeof(loctype)-1; i>=0; i--) {
  62. 		n = p[0];
  63. 		putchar(hexnibble(n>>4&0xF));
  64. 		putchar(hexnibble(n&0xF));
  65. 		p--;
  66. 		}
  67. 	putchar(EOL);
  68. 	}
  69.  
  70.  
  71. //slightly better is doing a union to join a byte array to the value
  72. //Note: the following code is horrific. wastes memory, order dependant, no floats.
  73. void puts_hex_f2(loctype h2) {
  74. 	union {
  75. 		loctype val; 
  76. 		unsigned char b[sizeof(loctype)];
  77. 		} h;
  78. 	h.val=h2;
  79. 	char i;
  80. 	for (i=sizeof(loctype)-1;i>=0;i--) {
  81. 		putchar(hexnibble(h.b[i]>>4&0xF));
  82. 		putchar(hexnibble(h.b[i]&0xF));
  83. 		}
  84. 	putchar(EOL);
  85. 	}
  86. //That isn't bad if you want to show the internal representation of a value...
  87. //and again, if you have a buffer, life is grand
  88.  
  89.  
  90. void puts_hex_b(loctype h) {
  91. 	char buf[sizeof(loctype)*2+1];
  92. 	char i;
  93. 	buf[sizeof(loctype)*2+1]=0; //need a trailing zero to output via puts Thanks Aram!
  94. 	for (i = sizeof(loctype)*2-1; i>=0; i--) { //down count is faster
  95. 		buf[i] = hexnibble((unsigned char)h&0xF);
  96. 		h/=16; // easily optimized by most compilers
  97. 		}
  98. 	puts(buf);
  99. 	}
  100.  
  101. int main(void) {
  102. 	puts_hex_b(value);
  103. 	puts_hex_f2(value);
  104. 	puts_hex_f(value);
  105. 	puts_hex_r(value);
  106. 	printf("%04X", value); 
  107. 	putchar(EOL);
  108.  
  109. 	putchar(hexnibble(0));
  110. 	putchar(hexnibble(1));
  111. 	putchar(hexnibble(2));
  112. 	putchar(hexnibble(3));
  113. 	putchar(hexnibble(4));
  114. 	putchar(hexnibble(5));
  115. 	putchar(hexnibble(6));
  116. 	putchar(hexnibble(7));
  117. 	putchar(hexnibble(8));
  118. 	putchar(hexnibble(9));
  119. 	putchar(hexnibble(10));
  120. 	putchar(hexnibble(11));
  121. 	putchar(hexnibble(12));
  122. 	putchar(hexnibble(13));
  123. 	putchar(hexnibble(14));
  124. 	putchar(hexnibble(15));
  125.  
  126.  
  127.  
  128. 	return 0;
  129. }
  130.  
Success #stdin #stdout 0s 4548KB
comments (?)
stdin 
Standard input is empty
stdout 
00000000DEADBEEF�
00000000DEADBEEF
00000000DEADBEEF
FEEBDAED00000000
DEADBEEF
0123456789ABCDEF
https://ideone.com/HDqleJ
Shortest possible binary to hex nibble which is easy for the C compiler to optimize.
language:
C (gcc 8.3)
created:
6 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!