How to get the value of individual bytes of a variable?

Question

I know that to get the number of bytes used by a variable type, you use sizeof(int) for instance. How do you get the value of the individual bytes used when you

Answer 1

You can get the bytes by using some pointer arithmetic:

int x = 12578329; // 0xBFEE19
for (size_t i = 0; i < sizeof(x); ++i) {
  // Convert to unsigned char* because a char is 1 byte in size.
  // That is guaranteed by the standard.
  // Note that is it NOT required to be 8 bits in size.
  unsigned char byte = *((unsigned char *)&x + i);
  printf("Byte %d = %u\n", i, (unsigned)byte);
}

On my machine (Intel x86-64), the output is:

Byte 0 = 25  // 0x19
Byte 1 = 238 // 0xEE
Byte 2 = 191 // 0xBF
Byte 3 = 0 // 0x00

Answer 2

This should work:

int x = 125;
unsigned char *bytes = (unsigned char *) (&x);
unsigned char byte0 = bytes[0];
unsigned char byte1 = bytes[1];
...
unsigned char byteN = bytes[sizeof(int) - 1];

But be aware that the byte order of integers is platform dependent.

Answer 3

If you want to get that information, say for:

int value = -278;

(I selected that value because it isn't very interesting for 125 - the least significant byte is 125 and the other bytes are all 0!)

You first need a pointer to that value:

int* pointer = &value;

You can now typecast that to a 'char' pointer which is only one byte, and get the individual bytes by indexing.

for (int i = 0; i < sizeof(value); i++) {
    char thisbyte = *( ((char*) pointer) + i );
    // do whatever processing you want.
}

Note that the order of bytes for ints and other data types depends on your system - look up 'big-endian' vs 'little-endian'.

Answer 4

You have to know the number of bits (often 8) in each "byte". Then you can extract each byte in turn by ANDing the int with the appropriate mask. Imagine that an int is 32 bits, then to get 4 bytes out of the_int:

  int a = (the_int >> 24) & 0xff;  // high-order (leftmost) byte: bits 24-31
  int b = (the_int >> 16) & 0xff;  // next byte, counting from left: bits 16-23
  int c = (the_int >>  8) & 0xff;  // next byte, bits 8-15
  int d = the_int         & 0xff;  // low-order byte: bits 0-7

And there you have it: each byte is in the low-order 8 bits of a, b, c, and d.

Answer 5

You could make use of a union but keep in mind that the byte ordering is processor dependent and is called Endianness http://en.wikipedia.org/wiki/Endianness

#include <stdio.h>
#include <stdint.h>

union my_int {
   int val;
   uint8_t bytes[sizeof(int)];
};

int main(int argc, char** argv) {
   union my_int mi;
   int idx;

   mi.val = 128;

   for (idx = 0; idx < sizeof(int); idx++)
        printf("byte %d = %hhu\n", idx, mi.bytes[idx]);

   return 0;
}