Verständnisfrage

llm

pro ziffer 4 bit also 16 bei denen

stimm schon mal

a= A0f3 =11110011

ich dachte per Ziffer 4 bits - wiso sind das dann bei dir 8 bits?

a= A0f3 =11110011 & FF = 11111111 sind gleich wie FF

keine Ahnung wie auch immer du das machst aber es ist falsch

nimm doch erst mal alle Werte und schreib dazu die Binärdarstellung auf

0xA0F3 => 0b????...
0xFF => 0b????...
0x00F3 => 0b????...
0x0101 => 0b????...

und dann schau dir nochmal genau an was '&' und '|' machen

razor

also ich hab die hexadezimal werte einfach hier eingegeben
https://tools.piex.at/zahlen-umrechner/

llm

@razor

also ich hab die hexadezimal werte einfach hier eingegeben

sehr gut - aber

A0f3 =11110011

stimmt trotzdem nicht (du schriebst, 4 bits pro hex-Ziffer, ich zähle 4 hex-ziffer * 4 ergibt wie viele Bits?)

schreib doch einfach mal alle Werten für uns hin - so zum warm werden

0xA0F3 = 0b101........
usw.

hustbaer

@razor Schau dir den "Logic-Table" für "und" und "oder" an.
Dann rechne die Zahlen nochmal in Binär um und dann kannst du das Ergebnis der beiden Ausdrücke selbst manuell ermitteln - auch wieder in Binärdarstellung. Das Ergebnis rechnest du dann wieder nach Hex um. Und dann weisste du bei beiden Ausdrücken/Aussagen ob sie wahr oder falsch sind.

Dabei sollte dir dann auffallen dass man Dinge wie a & 0xFF, a | 0xFF, a & 0xF00F etc. sehr einfach direkt in der hexadezimalen Darstellung ermitteln kann. Also alle "und" und "oder" Verknüpfungen wo nur 0er und Fs vorkommen.

*john 0

@razor sagte in Verständnisfrage:

also ich hab die hexadezimal werte einfach hier eingegeben
https://tools.piex.at/zahlen-umrechner/

Bei dieser Aufgabe brauchst Du die Zahlen gar nicht umzurechnen! Das sieht man direkt

unsigned short a = 0xA0F3;
unsigned short b = 0x00FF; // = 0xFF und untereinander geschrieben, damit man es gleich sieht.

bool bb = ((a & b) == 0x00F3); // Frage ist der Wert wahr oder falsch?

razor

Dank! Hab alles in Binärzahlen umgerechnet und aufgezeichnet, quasi wie eine Maske dass man die Bits ut zählen kann.

a = 0xA0F3=> 1010000011110011
0xFF=> 11111111
F3=> 11110011
0X0101=> 100000001
0101=> 100000001

unsigned short a = 0xA0F3;
Bewerten Sie die folgende Aussage: (a & 0xFF) == 0x00F3 sollte wahr sein!
weil 1010000011110011
11111111 &
11110011

(a | 0x0101) == 0xA0F3 Falsch weil
1010000011110011
100000001 | Operator
1010000111110011
somit Ungleich 1010000011110011

razor

Kann mir wer dazu jemad etwas sagen?
Welche Größe hat folgendes Objekt?
char str[] = "a short string";
Würde sich etwas an der Größe ändern, wenn man char[] durch char* ersetzte? Begründen Sie Ihre Antwort.

DirkB

@razor kennst du den Unterschied?

razor

Dieser Beitrag wurde gelöscht!

hustbaer

@razor sagte in Verständnisfrage:

Dank! Hab alles in Binärzahlen umgerechnet und aufgezeichnet, quasi wie eine Maske dass man die Bits ut zählen kann.

a = 0xA0F3=> 1010000011110011
0xFF=> 11111111
F3=> 11110011
0X0101=> 100000001
0101=> 100000001

unsigned short a = 0xA0F3;
Bewerten Sie die folgende Aussage: (a & 0xFF) == 0x00F3 sollte wahr sein!
weil 1010000011110011
11111111 &
11110011

Korrekt.

(a | 0x0101) == 0xA0F3 Falsch weil
1010000011110011
100000001 | Operator
1010000111110011
somit Ungleich 1010000011110011

Ebenfalls korrekt.

hustbaer

@razor sagte in Verständnisfrage:

Kann mir wer dazu jemad etwas sagen?
Welche Größe hat folgendes Objekt?
char str[] = "a short string";

Wenn du ein char Array ohne explizite Grössenangabe mit einem String-Literal initialisierst, dann wird das char Array dabei genau so gross gemacht dass es den String plus abschliessendem NUL Byte halten kann.

Würde sich etwas an der Größe ändern, wenn man char[] durch char* ersetzte? Begründen Sie Ihre Antwort.

Bei der Initialisierung eines char-Zeigers mit einem String-Literal wird ein char-Zeiger erzeugt der auf einen NUL-terminierten String zeigt. Der char-Zeiger bleibt aber natürlich ein char-Zeiger. D.h. auch die Grösse des "str" Objekts ist die Grösse eines char-Zeigers.