Hallo!
Eigentlich hast du da zwei Möglichkeiten. Entweder du stellst die Dezimalzahl dann als String dar, oder als Binay coded decimal. Mit bool kannst du vielleicht eine der unteren Funktionen umschreiben.
Hier die erste Version:
/* -----------------------------------------------------------------------
* Die Funktion buzubin wandelt den als int-Wert gegebenen Parameter 1
* in einem Binärwert vom Typ BYTE um. Dieser wird in Parameter 2 als
* String gespeichert. Es werden dabei immer 8 Stellen des Binärwertes
* gezeigt. Das neunte Byte im String dient zur String-Terminierung.
*Aufruf: buzubin( Char-Wert_als_int, &Binärwert_als_String);
*/
void buzubin(unsigned int letter, char wort[])
{
unsigned int slei, dum, testwert;
/* 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';
}
}
/* Die Funktion binzuza wandelt Binärwerte die als Strings gespeichert sind,
* in Dezimalzahlen um. Die erste Schleife dient zum feststellen der Stringlaenge
* ----------------------------------------------------------------------- */
void binzuza(unsigned int (*letter), unsigned char wort[])
{
unsigned int slei, ende, dumsm, dumza = 0, testwert = 1;
for (ende = 0; ende <= 8; ende++)
if (wort[ende] == '\0') break;
testwert<<= (ende - 1); /* Anpassung von testwert an Stringlaenge */
for (slei = 0; slei <= (ende - 1); slei++)
if ((wort[slei] == 'I') || (wort[slei] == '1'))
{
dumsm = testwert >> slei;
dumza += dumsm;
}
(*letter) = dumza;
}
Der Haken dabei ist, das du inclusive der Nullterminierung des Strings mindestens 9 Byte brauchst. Hier zur Sicherheit ein 12-Byte-Array für den String.
Nun die zweite:
// returns the number of digits of a integer value
long AnzahlStellen(long wert)
{
return floor (log10 (labs (wert))) + 1;
}
//converts a binary number stored as a 4byte integer to a integer value as decimalsystem
long bintoint(long binval)
{
long rewer = 0, stellen, slei, testwert, dummy, rest;
long wert, hochwert;
wert = binval;
stellen = AnzahlStellen(wert);
printf("Anzahl Stellen: %d\n", stellen);
if(stellen <= 32)
for (slei = stellen; slei >= 0; slei--)
{
testwert = pow(10, slei);
hochwert = pow(2, slei);
dummy = wert / testwert;
rest = wert % testwert;
printf("testwert: %12d dummy: %12d rest: %12d hochwert: %d\n", testwert, dummy, rest, hochwert);
if (dummy == 1) rewer += hochwert;
wert = rest;
}
return rewer;
}
Dabei kann man aber leicht übersehen, das dies eine binäre Zahl ist, die in Form einer Dezimalzahl dargestellt wird. Also Vorsicht. Der Vorteil ist, das du nur 4 Byte für das int brauchst, je nach CPU und Implementierung.
Eine dritte wäre über Bitfelder. Aber über Bitfelder eine Dezimalzahl in eine binäre umzuwanlen, das habe ich noch nicht probiert.
Nur hier ein einziger Versuch von mir mit so was zu experimentieren:
/**strinit.cpp demonstriert das Prinzip von Bitfeldern */
#include <stdio.h>
#include <string.h>
/* define a structure with bit fields */
struct two_Bytes
{
unsigned short lbyte : 8;
unsigned short hbyte : 8;
} tb;
/* define a union with bit fields */
union mixed
{
unsigned short ganz;
struct two_Bytes tb;
} mx;
int main( )
{
unsigned short a, b, c;
a = 25;
b = 255;
c = b + (a << 8);
printf( "Example for struct, Bitfield and uoion\n\n");
printf( "Memory size occupied by two_Bytes: %lu Byte\n", sizeof(two_Bytes));
printf( "Memory size occupied by mixed....: %lu Byte\n\n", sizeof(mixed));
mx.tb.hbyte = 25;
mx.tb.lbyte = 255;
printf( "Sizeof( mxixed ) : %lu Byte\n", sizeof(mx) );
printf( "eg.tl.hbyte..... : %d\n", mx.tb.hbyte);
printf( "eg.tl.lbyte..... : %d\n", mx.tb.lbyte);
printf( "eg.ganz..... : %d\n", mx.ganz);
printf( "a = %d\nb = %d\n", a, b);
printf( "result of c = b +(a << 8) : %d\n", c);
return 0;
}
Die von mir geschriebenen obigen Funktionen stelle ich unter GPL-Lizenz.
