Bin grade wieder auf was gestoßen, welches mich irgendwie schon ein paar Mal gewundert hatte.

markieren

Code:

Codepage 1200 - Unicode (aka UTF-16)
Codepage 1201 - Unicode Big-Endian

Dieses kennen bestimmt Einige?

s := #$FEFF'123'; ergibt $FF $FE $31 $00 $32 $00 $33 $00 $34 $00 (Speicherauszug).
Dieses entspricht der Codepage 1200 und wenn man genau hinguckt,
dann ist das doch BigEndian, denn die höherwertige Bytes kommen als Letztes.

Was ist also nun richtig?


Ich komme zwar ständig beim Windows durcheinander, also ob der Integer Big- oder LitleEndian ist, also k.A. und vielleicht bin ich auch nur schonwieder falsch.

http://msdn.microsoft.com/en-us/library/dd317756.aspx

BigEndian = Höchwertigstes Byte kommt als erstes

$FEFF => FE FF = Big Endian
$FEFF => FF FE = Little Endian

Prinzipiell sind bei x86 CPUs alle Daten(typen) LittleEndian. (Es sei denn man speichert sie explizit "falschrum")

Zitat von Neutral General:

BigEndian = Höchwertigstes Byte kommt als erstes

Ich sag ja ... also doch falschrum (bei mir)

Ich glaub ich merk mir das nie, solange BigEndian nicht "mit Groß endend" übersetzt

Das dicke Ende (der Zahl) kommt zuerst ...

... ich merke es mir tatsächlich so, das ich weiß, das mein PC LittleEndian ist und dort die Zahlen "falsch herum" im Speicher liegen

Zitat von Neutral General:

BigEndian = Höchwertigstes Byte kommt als erstes

$FEFF => FE FF = Big Endian
$FEFF => FF FE = Little Endian

BigEndian, höchstwertiges Byte am Ende dachte ich... also umgekehrt!? (quasi Big Ende)

$1234 => 34 12 = Big Endian
$1234 => 12 34 = Little Endian

€: Nachgeschaut:

BigEndian, höchstwertigstes Byte an der höchsten Speicheradresse. Also im Stream am Ende ankommend?
LittleEndian, höchstwertiges Byte kommt an erster Speicheradresse, als erstes aus dem Stream, mit niedrigsten Index im String... (bin mir so langsam fast sicher)

(irgendwie glaube ich, Beschreibung richtig, Darstellung falsch umd bei NG umgekehrt?)

Also.. Nehmen wir mal dieses Zitat von Wikipedia:

Zitat:

Heutige PC-Systeme (x86-kompatible) verwenden Little-Endian.

dazu nehmen wir folgendes Programm:

zusammenfalten · markieren

Delphi-Quellcode:

program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;

var Int: Word;
    B: PByte;
begin
  Int := $ABCD;

  writeln('Wert: $ABCD');
  write('Speicher: ');

  B := @Int;
  write('$',IntToHex(B^,2),', ');

  inc(B);
  write('$',IntToHex(B^,2));

  readln;
end.

Und jetzt wissen wir was LittleEndian bedeutet.

Ich glaube Deine Darstellung war richtig, aber deine Beschreibung: "BigEndian = Höchwertigstes Byte kommt als erstes" passt doch nicht?

Auf der Wiki-Seite ist das höherwertige Byte bei BigEndian an der höchsten Speicheradresse, also als letztes?

Ich hab's jetzt... mich hat verwirrt, das im Beispiel das niederwertige Byte den größten Byte-Wert hatte.

mit Deinem Beispiel und
Int := $2211; hat es dann Klick gemacht

Also:

Wert: $ABCD

Höchstwertigstes Byte: $AB

Little Endian (von klein nach groß = "falsch rum"):

markieren

Code:

Speicheradresse    Wert
0000               $CD
0001               $AB

Big Endian (von groß nach klein = "richtig rum"):

markieren

Code:

Speicheradresse    Wert
0000               $AB
0001               $CD

Ja, weil der Größere am Ende ist, heißt es LittleEndian

wer soll sich denn sowas merken

Also im Speicher ist es LittleEndian (klein..groß)
und als Integer im Quellcode nutzen wir BigEndian (groß..klein).

Zitat von Satty67:

(Doof, aber das Thema hat zum Glück auch andere etwas verwirrt )

praktisch, wenn man es immer mal wieder vergißt und quasi immer dann, wenn man's mal braucht

Zitat von himitsu:

Ja, weil der Größere am Ende ist, heißt es LittleEndian

Es ist nunmal das vordere Ende gemeint, nicht das hintere

Big Endian -> groß (MSB) am vorderen Ende
Little Endian -> klein (LSB) am vorderen Ende