0 Daumen
107 Aufrufe

Frage:

Ich muss dieses Beispiel ausprogrammieren, weiß aber nicht genau wie die Schnitstelle zu implementieren ist.? Wie würde ich die Funktion aufrufen und wie werden die Parameter übergeben?

Beispiel 1 (6 Punkte) Zahlensysteme, C++ Praxis: Schreiben Sie eine Funktion Decimal2Dual, die eine gegebene Dezimalzahl vom Datentyp int in eine Dualzahl umrechnet. Zur Lösung dieser Aufgabe beschränken Sie sich auf Dezimalzahlen im Bereich von 0 bis 28-1 = 255. Realisieren Sie 2 Funktionen mit unterschiedlicher Schnittstelle: Beide Funktionen erhalten die Dezimalzahl als Eingangsparameter. Funktion 1 liefert die einzelnen acht Bits als acht Ausgangsparameter vom Datentyp bool zurück und Funktion 2 als bool-Feld der Länge acht.


Code:

#include <iostream>
using namespace std;
bool zero = 0;
bool one = 0;
bool two = 0;
bool three = 0;
bool four = 0;
bool five = 0;
bool six = 0;
bool seven = 0;

void Decimal2DualArray(int num, bool &zero, bool &one, bool &two, bool &three, bool &four, bool &five, bool &six, bool &seven){

 
  bool byte[8] = {zero, one, two, three, four, five, six, seven};
 
  for (int i = 7; i > 0; i-- ){
      byte[i] = num % 2;
      num = num / 2;
     
}

}



int main() {
  cout << Decimal2DualArray(12, 0, 0, 0, 0, 0, 0, 0, 0) << endl;
return 0;
}
von

Auch wenn die Frage schon älter ist, aber vielleicht für manche hilfreich

1 Antwort

+1 Daumen

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.

von

Dein Beispiel etwas modifiziert:

#include <iostream>

struct Bits{

bool bitsofByte[8];
}bt = {0};

void Decimal2DualArray(int num, struct Bits *bt)
{
int i, testval = 128, shifted, ANDvalue; 

for (i = 0; i < 8; i++)
{
shifted = testval >> i;
ANDvalue = num & shifted;
bt->bitsofByte[i] = ANDvalue / shifted;
}

}

void ShowBool(struct Bits bt)
{
int i; 


for (i = 0; i < 8; i++)
{
  std::cout << bt.bitsofByte[i]; 
}
std::cout << std::endl;
}


int main(int argc, char **argv)
{
int value = 193;

std::cout << "size of bool in Byte: " << sizeof(bool) << std::endl;
std::cout << "decimal value = " << value << std::endl;
Decimal2DualArray(value, &bt);
ShowBool(bt);
return 0;
}

Wenn du die bool-Werte in eine struct packst, wird die Anzahl der Argumente(Parameter) nicht so lange.binbool.jpg

Text erkannt:

\( \begin{array}{cccc}\boldsymbol{x} & \text { Terminal } & \mathrm{V} \wedge\end{array} \)
Datei Bearbeiten Ansicht Suchen Terminal Hilfe
size of bool in Byte: 1 decimal value \( =193 \) 11000001
Hit any key to continue...

Nun das Beispiel mit den Bitfeldern, wobei das letzte dazu umgeschrieben wurde:

#include <iostream>

struct Bits
{
bool bitsofByte[8];
}bt = {0};

struct eightbit
{
bool bit0 : 1;
bool bit1 : 1;
bool bit2 : 1;
bool bit3 : 1;
bool bit4 : 1;
bool bit5 : 1;
bool bit6 : 1;
bool bit7 : 1;

} eb;

union mixbyte
{
unsigned char bytewert;
struct eightbit eb;       

}mibi;

void Decimal2DualArray(int num, struct Bits *bt);
void ShowBool(struct Bits bt);


int main(int argc, char **argv)
{
int value = 193;
union mixbyte mibi;


std::cout << "size of bool in Byte: " << sizeof(bool) << std::endl;
std::cout << "decimal value = " << value << std::endl;
Decimal2DualArray(value, &bt);
ShowBool(bt);
std::cout << "-----boolwerte:----------------" << std::endl;
mibi.bytewert = 193;

std::cout << "bytewert = " << (int)mibi.bytewert << std::endl;
std::cout << "bit7 = " << mibi.eb.bit7 << std::endl; 
std::cout << "bit6 = " << mibi.eb.bit6 << std::endl;
std::cout << "bit5 = " << mibi.eb.bit5 << std::endl; 
std::cout << "bit4 = " << mibi.eb.bit4 << std::endl;
std::cout << "bit3 = " << mibi.eb.bit3 << std::endl; 
std::cout << "bit2 = " << mibi.eb.bit2 << std::endl;
std::cout << "bit1 = " << mibi.eb.bit1 << std::endl; 
std::cout << "bit0 = " << mibi.eb.bit0 << std::endl;
std::cout << "---------------------" << std::endl; 


return 0;
}

void Decimal2DualArray(int num, struct Bits *bt)
{
int i, testval = 128, shifted, ANDvalue; 

for (i = 0; i < 8; i++)
{
shifted = testval >> i;
ANDvalue = num & shifted;
bt->bitsofByte[i] = ANDvalue / shifted;
}

}

void ShowBool(struct Bits bt)
{
int i; 

for (i = 0; i < 8; i++)
{
  std::cout << bt.bitsofByte[i]; 
}
std::cout << std::endl;
}

Hier die dazugehörige Ausgabe am Terminal:

binbool-bitfelder.jpg

Ein anderes Problem?

Stell deine Frage

Willkommen bei der Stacklounge! Stell deine Frage einfach und kostenlos

x
Made by a lovely community