Bitweises Shiften

[Whiz-zarD]

Moin.
Ich hab da mal eine kurze Frage. In einer alten Klausur steht folgender Pascal-Code:

Code (pascal):

 
i:integer;
 
i := -1;
writeln(i shr 14);
 

Man soll nun bestimmen, was auf dem Bildschirm ausgegeben wird.
In binärer Form wäre -1 ja 1111 1111 1111 1111
Nun soll das Ganze um 14 Stellen nach Rechts verschoben werden. Dann kommt nach meiner Überlegung 0000 0000 0000 0011 raus, was ja 3 entspricht.

Geb ich nun den Codeschnippsel unter Pascal ein, bekomm ich 262143, was 0011 1111 1111 1111 1111 entspricht, heraus.

Wo liegt da mein Denkfehler?

[Kyuu]

Du musst dir mehr Gedanken über die Größe der Datentypen machen, denn ein Integer auf einem 32-bit System ist nicht 16, sondern 32 Bit groß.
Wenn man das beachtet, ist -1 nicht 11111111 11111111, sondern 11111111 11111111 11111111 11111111 und -1 um 14 Stellen nach rechts geschoben ist dann logischerweise 00000000 00000011 11111111 11111111, exakt deine Ausgabe.

[Whiz-zarD]

Dann versteh ich aber nicht, wieso in meinen Unterlagen steht, dass Integer 2 Bytes groß und Vorzeichenbehaftet ist und 2 Bytes sind bei mir 16 Bits.

[Lukas]

Nope, das ist Maschinen- (und ich denke teilweise sogar Compiler-) abhängig. Und da 262143 größer als 32767 (und 65535) ist, kann's bei dir schonmal nicht 16 bit sein.
Kurz: deine Unterlagen stammen entweder aus der 16 bit-Ära oder ihr Autor war inkompetent :P

[Whiz-zarD]

Nope, das ist Maschinen- (und ich denke teilweise sogar Compiler-) abhängig. Und da 262143 größer als 32767 (und 65535) ist, kann's bei dir schonmal nicht 16 bit sein.
Kurz: deine Unterlagen stammen entweder aus der 16 bit-Ära oder ihr Autor war inkompetent :P

...

wenn ich aber unter Pascal

Code (pascal):

writeln(sizeof(integer));

eingebe, dann zeigt er mir eine größe von 2 Bytes, also 16 Bit, an.

[Brauni90]

Wie bereits mein Vorredner erwähnte, ist das abhängig von der Maschine, dem Betriebssystem und dem Compiler.

Code (pascal):

writeln(sizeof(integer));

[...] dann zeigt er mir eine größe von 2 Bytes, also 16 Bit, an.

...

Ich kenne Pascal nicht im Detail, aber ich kann mir vorstellen, dass der Compiler den 'integer' als 32bit interpretiert oder konvertiert (Zweierkomplement), diesen dann bitweise schiebt und dann als Parameter an die Funktion 'writeln' übergibt. Probier mal

Code (pascal):

writeln(i shr (14+16));

[Drakes]

Ich weiss nicht, welchen Compiler du verwendest, aber bei GNU Pascal kannst du die Grösse explizit angeben um auch sicher diese Grösse zu bekommen.
Mich würde interessieren, was dann ausgegeben wird:

Code (Pascal):

 
i:Integer attribute (Size = 32);
writeln(sizeof(i));
 

Wobei du ja sizeof(Integer) verwendet hast, was aber auf das selber herauskommen sollte.

[Whiz-zarD]

Ich kenne Pascal nicht im Detail, aber ich kann mir vorstellen, dass der Compiler den 'integer' als 32bit interpretiert oder konvertiert (Zweierkomplement), diesen dann bitweise schiebt und dann als Parameter an die Funktion 'writeln' übergibt. Probier mal

Code (pascal):

writeln(i shr (14+16));

...

Dann spuckt er auch die 3 aus.
Nur ich frage mich, wieso er dann Integer als 32 Bit-Wert interpretiert, wenn alle Funktionen, die zur Ermittlung der maximalen Größe dienen, alle 16 Bit ausspucken. Sizeof(integer) sagt 2 bytes und BitSizeof(integer) sagt 16 Bit.

[Mog]

Nope, das ist Maschinen- (und ich denke teilweise sogar Compiler-) abhängig. Und da 262143 größer als 32767 (und 65535) ist, kann's bei dir schonmal nicht 16 bit sein.
Kurz: deine Unterlagen stammen entweder aus der 16 bit-Ära oder ihr Autor war inkompetent :P

...

Mach maschinen-, compiler- und Sprachabhaengig daraus.

Im uebrigen verwenden auch nicht alle Prozessoren 2Bc. Du hast Glueck, dass du eine Intel-Kiste hast. Bei einem Generation wuerde dein Bit-Haufen auch schon wieder anders aussehen.

Die meisten Inseln verwenden die Negativdarstellung der Prozessoren, und ihre eigene Groessen. Darum verwendet man auch nur uints fuer Flags. Nervende Geschichte, manchmal, wenn man mit Binaerdaten arbeitet.

/Vermutlich, weil sizeof ein statischer Operator ist. Ein bool hat ja in Wirklichkeit auch eher die Groesse eines Wortes.

[Kyuu]

Compiler/Sprachen bieten oft Datentypen an, die bestimmte Größen zusichern. Es gibt beispielsweise Datentypen mit exakten Größen, die sich unter anderen Umständen garantiert nicht ändern und es gibt Datentypen mit einem zugesicherten Minimum, d.h. du kannst dich darauf verlassen, dass der Datentyp mindestens diese Größe hat, kann aber auch größer sein. Für den Compiler sind die letzteren Datentypen aus optimierungstechnischen Gründen von Vorteil, da er bei Datentypen, die kleiner als das Maschinenwort sind (ein Maschinenwort auf einem 16-bit System ist 16 Bit, auf einem 32-bit System 32 Bit und auf einem 64-bit System 64 Bit groß) auf einen Datentyp ausweichen kann, der exakt die Größe des Maschinenwortes hat. Da der Prozessor auf Daten mit der Größe des Maschinenwortes ausgelegt ist, müsste der Compiler jedes mal wenn mit kleineren Datentypen als das Maschinenwort gerechnet wird, diese Datentypen erst auf die Größe des Maschinenwortes konvertieren, an den Prozessor übergeben und nach der Berechnung wieder zurückkonvertieren. Bei Datentypen, die eine minimale Größe fordern, aber nach oben keine Grenze setzen, ist der Compiler nicht mehr gezwungen Konvertierungsoperationen (die in der Regel eine Folge von Schiebe- und Verknüpfungsoperationen sind) einzusetzen und kann die Daten direkt an den Prozessor übergeben.

Edit: Etwas umformuliert. :0