Simple way to store a 64 bit unsigned long into four unsigned short with union

Hi guys!

Here is a simple program what shows how to store a 8 byte long unsigned long into 4 unsigned short:
first the header lintunion.h:

Code:

---

#ifndef LONGINTUNION_H_INCLUDED
#define LONGINTUNION_H_INCLUDED

#include <iostream>
#include <iomanip>

union einheit
 {
  unsigned long ulwert;
  unsigned char mwertbytes[8];
  unsigned short mwertushort[4];
 };

 void buzubin(unsigned int letter, char wort[]);
 void zeigeWerte(union einheit ehe);
 void dectoshort( unsigned short zahl, char zudi[], short vornullen);

#endif // FLOATINTUNION_H_INCLUDED

---

now lintunion.cpp

Code:

---

#include "lintunion.h"

/* -----------------------------------------------------------------------
 * buzubin converts a decimal value(only 0 to 255) given by argument 1
 * in to a binary value shown as string. This string is stored in argument 2.
 * The sting shows all eight bit of the value in argument 1.
 * the other bytes is for to terminate the string
 * syntaxc:  buzubin( char-value_as_int, Binaer_value_as_string);
 */

void buzubin(unsigned int letter, char wort[])
{
unsigned int slei, dum, testwert;
 if ((letter < 0) || (letter > 255)) goto finito;

 /* Ininitalisert die 8 Binärstellen mit Null */
 for (slei = 0; slei <= 11; slei++)
  wort[8] = '\0';

 for (slei = 0; slei <= 7; slei++)
  {
  testwert = 128 >> slei;  /* Bit7(128dez) ist auf Char-Nr.0 */
  dum = letter & testwert;
  if (dum != 0)  wort[slei] = '1';
    else          wort[slei] = '0';
  }
finito:    ;
}

// shows all values
void zeigeWerte(union einheit ehe)
{
 int i;
 char binwort[15], longwort[100];

 //Werte von unsigned char zeigen
  std::cout << "unsigned long value: " << ehe.ulwert << "    binary: ";

  for (i = 7; i >= 0; i--)
  {
    buzubin(ehe.mwertbytes[i], binwort);
    std::cout << binwort << " ";
  }
  std::cout <<std::endl;   
 std::cout <<"Now as unsigned char: " << std::endl;
 for (i = 7; i >= 0; i--)
  {
  buzubin(ehe.mwertbytes[i], binwort);
  std::cout << "mwertbytes[" << i << "] = " << std::setw(3) << (int)ehe.mwertbytes[i] << "  binary: " <<  binwort << std::endl;
  }
 //Werte von unsigned char zeigen
 std::cout << std::endl << "Nun als unsigned short: " << std::endl;
 for (i = 3; i >= 0; i--)
  {
  dectoshort( (unsigned long)ehe.mwertushort[i], longwort, 1);
  std::cout << "mwertshort[" << i << "] = " << std::setw(6) << (int)ehe.mwertushort[i] << "  binary: " << longwort <<std::endl;
  }
 std::cout << "---------------------------------------------------------" << std::endl;
}

/** converts arg 1(unsigned short decimal)
  * in a char-string (argument2), if argument 3(with leading zeros) 0
  * the leading Zerows will not shown in sthe string, else
  * with leading zeros
  */
void dectoshort( unsigned short zahl, char zudi[], short vornullen)
{
char wort[35], worz[35];
int slei, sleib;
unsigned short dum2, testwert, kon = 1;
// String vorbereiten
for (slei = 0; slei <= 34; slei++)
wort[slei] = worz[slei] = '\0';

kon <<= 15;

for (slei = 0; slei <= 15; slei++)
  {
  testwert = kon >> slei;  /* Bit30(1073741824dez) is char number 0 */
  dum2 = zahl & testwert;
  if (dum2)  wort[slei] = '1';
    else    wort[slei] = '0';
  }
// begin to set ende of leading zeros
for (slei = 0; slei <= 15; slei++)
 if (wort[slei] == '1') break;
// wort ist mit Vornullen, worz ohne Vornullen
 for (sleib = 0; sleib <= 32; sleib++)
        {
        worz[sleib] = wort[slei];
        if (wort[slei] == '\0')
          break;
        slei++;
        }
// take result in to argument 2
 for (slei = 0; slei <= 15; slei++)
  if ( vornullen == 0)
  zudi[slei] = worz[slei]; /* if arg 3(vornullen) = 0 string with no leading zeros */
    else
    zudi[slei] = wort[slei]; // if arg 3 = 1 then with leading zeros

}

---

here main.cpp:

Code:

---

#include <iostream>
#include "lintunion.h"


int main()
{
 union einheit flint;

 std::cout << "Test" << std::endl;
 std::cout << "length of long int: " << sizeof(long int) << " byte" << std::endl;
 std::cout << "length of short...: " << sizeof(short) << " byte"  << std::endl << std::endl;

 flint.ulwert = 1234567890;

 //Werte von unsigned char zeigen
 zeigeWerte(flint);

 flint.ulwert = 0;

 std::cout << std::endl <<"Now all variables are deleted:" << std::endl;

 //Werte von unsigned char zeigen
 zeigeWerte(flint);

 flint.mwertushort[0] = 59861;
 flint.mwertushort[1] = 17142;
 flint.mwertushort[2] = 9861;
 flint.mwertushort[3] = 7142;

 #include <iostream>
#include "lintunion.h"


int main()
{
 union einheit flint;

 std::cout << "Test" << std::endl;
 std::cout << "length of long int: " << sizeof(long int) << " byte" << std::endl;
 std::cout << "length of short...: " << sizeof(short) << " byte"  << std::endl << std::endl;

 flint.ulwert = 1234567890;

 //Werte von unsigned char zeigen
 zeigeWerte(flint);

 flint.ulwert = 0;

 std::cout << std::endl <<"Now all variables are deleted:" << std::endl;

 //Werte von unsigned char zeigen
 zeigeWerte(flint);

 flint.mwertushort[0] = 59861;
 flint.mwertushort[1] = 17142;
 flint.mwertushort[2] = 9861;
 flint.mwertushort[3] = 7142;

  //Werte von unsigned char zeigen
 zeigeWerte(flint);

 return EXIT_SUCCESS;
}


 //Werte von unsigned char zeigen
 zeigeWerte(flint);

 return EXIT_SUCCESS;
}

---

output on screen:

Code:

---

Test
length of long int: 8 byte
length of short...: 2 byte

unsigned long value: 1234567890    binary: 00000000 00000000 00000000 00000000 01001001 10010110 00000010 11010010
Now as unsigned char:
mwertbytes[7] =  0  binary: 00000000
mwertbytes[6] =  0  binary: 00000000
mwertbytes[5] =  0  binary: 00000000
mwertbytes[4] =  0  binary: 00000000
mwertbytes[3] =  73  binary: 01001001
mwertbytes[2] = 150  binary: 10010110
mwertbytes[1] =  2  binary: 00000010
mwertbytes[0] = 210  binary: 11010010

Nun als unsigned short:
mwertshort[3] =      0  binary: 0000000000000000
mwertshort[2] =      0  binary: 0000000000000000
mwertshort[1] =  18838  binary: 0100100110010110
mwertshort[0] =    722  binary: 0000001011010010
---------------------------------------------------------

Now all variables are deleted:
unsigned long value: 0    binary: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
Now as unsigned char:
mwertbytes[7] =  0  binary: 00000000
mwertbytes[6] =  0  binary: 00000000
mwertbytes[5] =  0  binary: 00000000
mwertbytes[4] =  0  binary: 00000000
mwertbytes[3] =  0  binary: 00000000
mwertbytes[2] =  0  binary: 00000000
mwertbytes[1] =  0  binary: 00000000
mwertbytes[0] =  0  binary: 00000000

Nun als unsigned short:
mwertshort[3] =      0  binary: 0000000000000000
mwertshort[2] =      0  binary: 0000000000000000
mwertshort[1] =      0  binary: 0000000000000000
mwertshort[0] =      0  binary: 0000000000000000
---------------------------------------------------------

Jetzt Zuweisung von Werten an short-Variable:
unsigned long value: 2010336637463488981    binary: 00011011 11100110 00100110 10000101 01000010 11110110 11101001 11010101
Now as unsigned char:
mwertbytes[7] =  27  binary: 00011011
mwertbytes[6] = 230  binary: 11100110
mwertbytes[5] =  38  binary: 00100110
mwertbytes[4] = 133  binary: 10000101
mwertbytes[3] =  66  binary: 01000010
mwertbytes[2] = 246  binary: 11110110
mwertbytes[1] = 233  binary: 11101001
mwertbytes[0] = 213  binary: 11010101

Nun als unsigned short:
mwertshort[3] =  7142  binary: 0001101111100110
mwertshort[2] =  9861  binary: 0010011010000101
mwertshort[1] =  17142  binary: 0100001011110110
mwertshort[0] =  59861  binary: 1110100111010101
---------------------------------------------------------

---

Have much fun to work with them!

Trivial, but your code has several errors (exemple: shifting a signed integer left) and since this is a C language programming forum, it is completely wrong...

Here's a more direct way to convert a byte to ascii binary representation:

Code:

---

#include <stdio.h>

char *bin2ascii_char( unsigned char ch )
{
  static char buffer[9];
  char*p;
  int count = 8;

  // Notice ch is 'unsigned char', so right shift is well defined by ISO 9989
  p = buffer;
  while ( count-- )
    *p++ = '0' + ( ( ch >> count ) & 1 );
  *p = '\0';

  return buffer;
}
/* Or:
char *bin2ascii_char( char ch )
{
  static char buffer[9];
  char *p;
  int count;

  p = buffer;
  count = 8;
  while ( count-- )
  {
    *p++ = '0' + ( ch < 0 );

    // left shifts for signed types are well defined.
    ch <<= 1;
  }

  *p = '\0';

  return buffer;
}
*/

int main( void )
{
  printf( "%d -> 0b%s\n", 240, bin2ascii_char( 240 ) );
}

---

Of course, assuming 'char' is byte sized.