Verständnisfrage



  • 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