title: Working with individual bytes using unsigned char arrays
body: <p>I've searched through many sites and can not seem to find anything relevant.</p>
  
  <p>I would like to be able to take the individual bytes of each default data types such as short, unsigned short, int, unsigned int, float and double, and to store each individual byte information(binary part) into each index of the unsigned char array. How can this be achieved?</p>
  
  <p>For example:</p>
  
  <pre><code>int main() {
      short sVal = 1;
      unsigned short usVal = 2;
      int iVal = 3;
      unsigned int uiVal = 4;
      float fVal = 5.0f;
      double dVal = 6.0;
  
      const unsigned int uiLengthOfShort  = sizeof(short);
      const unsigned int uiLengthOfUShort = sizeof(unsigned short);
      const unsigned int uiLengthOfInt    = sizeof(int);
      const unsigned int uiLengthOfUInt   = sizeof(unsigned int);
      const unsigned int uiLengthOfFloat  = sizeof(float);
      const unsigned int uiLengthOfDouble = sizeof(double);
  
      unsigned char ucShort[uiLengthOfShort];
      unsigned char ucUShort[uiLengthOfUShort];
      unsigned char ucInt[uiLengthOfInt];
      unsigned char ucUInt[uiLengthOfUInt];
      unsigned char ucFloat[uiLengthOfFloat];
      unsigned char ucDouble[uiLengthOfDouble];
  
      // Above I declared a variable val for each data type to work with
      // Next I created a const unsigned int of each type's size.
      // Then I created unsigned char[] using each data types size respectively
      // Now I would like to take each individual byte of the above val's
      // and store them into the indexed location of each unsigned char array.
  
      // For Example: - I'll not use int here since the int is 
      // machine and OS dependent. 
      // I will use a data type that is common across almost all machines. 
      // Here I will use the short as my example
  
      // We know that a short is 2-bytes or has 16 bits encoded
      // I would like to take the 1st byte of this short:
      // (the first 8 bit sequence) and to store it into the first index of my unsigned char[].
      // Then I would like to take the 2nd byte of this short:
      // (the second 8 bit sequence) and store it into the second index of my unsigned char[]. 
  
      // How would this be achieved for any of the data types?
  
      // A Short in memory is 2 bytes here is a bit representation of an 
      // arbitrary short in memory { 0101 1101, 0011 1010 }
      // I would like ucShort[0] = sVal's { 0101 1101 } &amp;
      //              ucShort[1] = sVal's { 0011 1010 } 
  
      ucShort[0] = sVal's First Byte info. (8 Bit sequence)
      ucShort[1] = sVal's Second Byte info. (8 Bit sequence)
  
      // ... and so on for each data type.
  
      return 0;
  }
  </code></pre>