Go Down

Topic: [gelöst] Warum ergibt sizeof(Data) immer ein Byte mehr? (Read 989 times) previous topic - next topic

Tommy56

Du hast es nicht verstanden. Damit kannst Du zwar zufällig etwas erreichen aber nicht gezielt.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)

HTML-Fan

Funktioniert das in etwa so:
Die RAM-Variante von
Code: [Select]
struct xyz{
  uint8_t a;
  uint16_t b;
  uint16_t c;
  uint32_t d;
};

ist
Code: [Select]

0: a
1: -
2: Lb
3: Hb
4: Lc
5: Hc
6: -
7: -
8: Ld
9: d
A: d
B: Hd
...

Also würde es Sinn machen, wenn man xyz in
Code: [Select]
struct xyz{
  uint32_t d;
  uint16_t b;
  uint16_t c;
  uint8_t a;
};

umformt, also nach Größe geordnet, damit die RAM-Variante
Code: [Select]

0: Ld
1: d
2: d
3: Hd
4: Lb
5: Hb
6: Lc
7: Hc
8: a
...

ist. Oder?

Tommy56

Ja. Die 32-Bit-Variablen an durch 4 teilbaren Anfängen anlegen und die 16-Bitt möglichst an durch 2 teilbaren.

Gruß Tommy
"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)

HTML-Fan


Tommy56

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)

HTML-Fan


Tommy56

Ja, brain Version 1.0 aber Vorsicht - oft gibt es nur die Betaversion 0.9 oder niedriger.

Gruß Tommy
"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)

HTML-Fan

Mir fällt gerade noch was ein - nach Größen ordnen reicht noch nicht. Wenn man
Code: [Select]
struct x{
  uint32_t a;
  uint16_t b;
};
struct y{
  x d;
  uint32_t c;
  uint16_t e;
};

, also alles nach Größe geordnet hat, dann ergibt das (ich lasse jetzt mal H und L weg)
Code: [Select]

0: a
1: a
2: a
3: a
4: b
5: b
6: -
7: -
8: c
9: c
A: c
B: c
C: e
D: e

, bei
Code: [Select]
struct x{
  uint32_t a;
  uint16_t b;
};
struct y{
  uint32_t c;
  x d;
  uint16_t e;
};

aber
Code: [Select]

0: c
1: c
2: c
3: c
4: a
5: a
6: a
7: a
8: b
9: b
A: e
B: e

, oder?

Tommy56

Schau Dir nochmal #32 an. Dein y ist nicht nach der Größe sortiert.

Es ist ja im Endeffekt:

Code: [Select]

  uint32_t a;
  uint16_t b;
  uint32_t c;
  uint16_t e;


Gruß Tommy
"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)

Serenifly

Es geht nicht darum dass nach der Größe zu sortieren sondern die Speichergrenzen zu berücksichtigen. Die Größe ist egal solange man 4 Byte große Blöcke hat

Tommy56

Ja und bei der angegebenen Reihenfolge hat man die für c halt nicht. Da wäre dann die andere Reihenfolge besser:

Code: [Select]

struct x{
  uint32_t a;
  uint16_t b;
};
struct y{
  x d;
  uint16_t e;
  uint32_t c;
};


Gruß Tommy
"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)

HTML-Fan

Hier wird's dann aber beknackt:
Code: [Select]
struct x{
  uint32_t a;
  uint16_t b;
  uint8_t c;
};
struct y{
  uint32_t d;
  x e;
  uint16_t f;
};

ergibt bei y
Code: [Select]

0: d
1: d
2: d
3: d
4: e.a
5: e.a
6: e.a
7: e.a
8: e.b
9: e.b
A: e.c
B: -
C: f
D: f

Bei struct y hat man dann

Code: [Select]

struct y{
  uint32_t d;

 [uint32_t e.a;
  uint16_t e.b;
  uint8_t e.c;]

  uint16_t f;
};

und da ist es unmöglich, alles richtig zu ordnen, da man ja nicht den struct so leicht zerpflücken und eine Variable dazwischenschieben kann. Gibt es echt nicht irgendeine Möglichkeit, mit der der Kompiler das zerlegt und ordnet? Da hilft nämlich nichtmal Brain 1.1 weiter.

Tommy56

Ich habe ja nicht behauptet, dass es immer möglich wäre ohne Ausrichtungs(füll)bytes auszukommen.
Man kann aber versuchen, Anordnungen zu wählen, die davon wenige brauchen. Um mehr geht es nicht.

Wie sollte der Kompiler etwas zerlegen und anders anordnen, was Du ihm anders vorgibst?

Gruß Tommy
"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)

HTML-Fan

Der Kompiler könnte
Code: [Select]
struct x{
  uint32_t a;
  uint16_t b;
  uint8_t c;
};
struct y{
  uint32_t d;
  x e;
  uint16_t f;
};

in
Code: [Select]

struct y{
  uint32_t d;
  uint32_t e.a;
  uint16_t e.b;
  uint8_t e.c;
  uint16_t f;
};

umformen und dann alles nach Größe ordnen, sodass
Code: [Select]

struct y{
  uint32_t d;
  uint32_t e.a;
  uint16_t e.b;
  uint16_t f;
  uint8_t e.c;
};

rauskommt. Da kann er sich, glaube ich, immer über die Entscheidung des Programmierers hinwegsetzen, denn der hat ja wahrscheinlich nichts gegen Optimierung. Schießlich optimieren Kompiler ja auchden Assembler-Code. Wenn das mal nicht der Fall sein sollte, könnte man sich doch ein schlaues Keyword wie "keep" oder so ausdenken und das setzt man einfach irgendwo in die Deklaration ein.

Tommy56

Darf er nicht, denn Du hast ihm mitgeteilt, dass Du auf e getrennt zugreifen willst. Deshalb muss e zusammen bleiben, weil Du es so gewollt hast.

Gruß Tommy
"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)

Go Up