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!