Verständnisfrage



  • Hallo kann mir zu folgenden Beispielen jemand etwas erklären?

    Was wird genau mit 0xA0F3 oder 0x00F3 gemeint?
    Gegeben sei folgende Definition:
    unsigned short a = 0xA0F3;
    Bewerten Sie die folgende Aussage: (a & 0xFF) == 0x00F3

    selbes auch hier
    Gegeben sei folgende Definition:
    unsigned short a = 0xA0F3;
    Bewerten Sie die folgende Aussage: (a | 0x0101) == 0xA0F3



  • @razor Zahlenliterale, die mit 0x anfangen, werden zur Basis 16 berechnet. Diese werden Hexadezimalzahlen genannt.

    & ist der binäre Und-Operator
    | ist der binäre Oder-Operator

    Die werden auch wie +,-,*,/ angewandt.

    Hexadezimalzahlen haben den Vorteil, dass die Ziffern (0 bis F) für jeweils 4 Bit stehen. So kann man die Bits besser erkennen.



  • ok Danke! also ist A0F3 als dezimalzahl 41203.
    und pro ziffer 4 bit also 16 bei denen

    also muesste bei dem bsp die antwort ja sein
    Bewerten Sie die folgende Aussage: (a & 0xFF) == 0x00F3
    weil sich bei a= A0f3 =11110011 & FF = 11111111 sind gleich wie FF.

    Bewerten Sie die folgende Aussage: (a | 0x0101) == 0xA0F3 sollte es faclsch sein



  • @razor

    weil sich bei a= A0f3 =11110011 & FF = 11111111 sind gleich wie FF.

    Das ergibt keinen Sinn.



  • 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



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



  • @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.



  • @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.



  • @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?
    


  • 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



  • 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.



  • @razor kennst du den Unterschied?



  • This post is deleted!


  • @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.



  • @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.


Log in to reply