Übungsaufgabe, ich verzweifle.

Für mich klingt das so das in der Struktur nur EINE Zahl zwischen 1 und 1024 gespeichert werden soll.

Schreiben Sie dazu 2 Funktionen, 1 Funktion welche die Struktur füllen soll mit dem per Parameter übergebenen Zahlenwert und andere Funktion zur Ausgabe des Zahlenwertes welcher in der Struktur enthalten ist.

Wie mann nun den Zahlenwert aufteilt ist doch eigentlich egal, hauptsache das ergebnis das die funktion ausgibt ist ein zahlenwert.

Green_Ghost

Die 2 Potenz, oder so...

2^0 2^1 2^2 2^3 2^4

es stellt die zahl im 0100111001100 Prinzip dar.
Schreibe eine funktion die alles verwandelt,
und eine die zurueck verwandelt.
suche mal in der <cmath> vieleicht hat es da was.
Sofern die idee richtig ist.

Qweety

struct  one_byte
{
unsigned char hexpot0; // 0 bis 15
unsigned char hexpot1; // 0 bis 15
unsigned char hexpot2; // 0 bis 15
}

Ist jetzt vielleicht Blödsinn, aber könnte das helfen, da 1024 = 0x400?

Qweety

Vergesst es, mit dem Rechnen hab ich's nicht so.

Qweety schrieb:

struct  one_byte
{
unsigned char hexpot0; // 0 bis 15
unsigned char hexpot1; // 0 bis 15
unsigned char hexpot2; // 0 bis 15
}
Ist jetzt vielleicht Blödsinn, aber könnte das helfen, da 1024 = 0x400?

Woems

Qweety schrieb:

struct  one_byte
{
unsigned char hexpot0; // 0 bis 15
unsigned char hexpot1; // 0 bis 15
unsigned char hexpot2; // 0 bis 15
}
Ist jetzt vielleicht Blödsinn, aber könnte das helfen, da 1024 = 0x400?

3x"unsigned char" = 3 Byte (zumindest denken so Professoren )

eigentlich geht es nicht 1024 Zahlen in 1 Byte = 8 Bit = 256 Kombinationen zu speichern

Vielleicht bekommt mans hin, wenn man das "komma" shiftet (aller float) 1000=1E4=1^4 (problem: 1024 -> 102E1 = 102^1 = 1020 )
float kann ja auch viel mehr zahlen aufnehmen, als es eigentlich groß ist.
Aber wie gesagt, es geht nur verlustbehaftet (auch bei float so)...

oder da wir heute den 1.4. haben, gehts auch ohne, nur ich verrate nicht wie :p
Damit mache ich Kohle bis zum "geht nicht mehr" . Und ich bin morgen reicher als Bill (und alle anderen reichen Säcke)

Warscheinlich hat euer Prof euch nur verarscht

Searence

// edit, mir ist gerade auf gefallen das ich die zehner und einer stelle maximal
bis 16 auslesen kann, war ein Denkfehler, vergesst das ganze besser wieder sorry

Trenne das Byte in 2 Nibble auf (4Bit)

Dann hast du folgendes:

0000 0000
0001 0001
0010 0010
0011 0011
0100 0100
0101 0101
0110 0110
0111 0111
1000 1000
1001 1001
1010 1010
1011 1011
1100 1100
1101 1101
1110 1110
1111 1111

Ein Nibble hat 16 Möglichkeiten etwas darzustellen.

Jetzt benutzt du das eine Nibble für die Tausender und Hunderterstelle
und das andere für die einer und Zehnerstelle.

Bsp:

0101 0111

Damit stellt du einmal 05 und einmal 07 da.

Ergibt = 0507;

die erste Null fällt natürlich weg, also hast du die Zahl 507

Hoffe das lässt sich in deinem Prog irgendwie verwirklichen, theoretisch müsste es gehen.

Searence

life

omg.. glaubt es: es geht nicht >_<

chris90

und wie willst du mit 2^4 möglichkeiten die zahl 24 darstellen?

ich bin übrigens immer noch für byte-vergrößern (am besten bastelt ihr euch ein mega-byte)

otze

ich bin dafür, dass jede zahl grundsätzlich erstmal durch 4 geteilt wird, der rest wird dann gespeichert. zur ausgabe alles wieder mal 4 rechnen, und wir haben eine schöne 75% werte reduzierung :p. In die nächsten 10 zeilen schreibt man dann folgendes:

2^8!=210

und geht dann schlafen :p

@searence gute idee, damit kommste bis 1616 hoch, leider ist in dem system die 1024 gerade nicht darstellbar

chris90

ich glaub da kann man auch gleich schlafen gehn ^^^

Woems

wenn du den prof verarschen willst, sag es geht und leg ihm nen prog vor, das etwa so aussieht:

#include "iostraem.h" // selbstgemachte iostream (unterschied im Namen nur durch ae/ea dreher

struct sbyte {
  bool bit1,bit2,bit3,bit4,bit5,bit6,bit7,bit8;
}

sbyte IntToSbyte(int t)
{
  // möglichst komplizierte nutzlose rechnung
}

int SbyteToInt(sbyte t)
{
  // möglichst komplizierte nutzlose rechnung
}

int main()
{
  int ibyte,obyte;
  sbyte magic;

  cin>>ibyte;  // gefacktes cin speichert den Wert versteckt im Hintergrund in ein int

  magic=IntToSByte(ibyte);
  // konvertierung: witzig, schön an zu sehen und absolut nutzlos*fg*
  obyte=SByteToInt(magic);

  cout<<obyte; // cout ignoriert den int und hohlt die Ausgabe aus dem versteckten int
}

Du kannst glück haben, wenn du das struct auch füllst. Vielleicht wird beim debuggen übersehen, dass magic nur schön aussieht, aber nix macht.

Hoffe es ist verständlich

*totmüde ins bett fall*