Katoch
Nach GCC __attribute__(packed ) packt an Bytegrenze, ausgerichtet wird für welchen Zweck verwendet :–
u8 rx_buf[14] __attribute__((aligned(8)));
struct S { short f[3]; } __attribute__ ((aligned (8)));
Das obige Array wird aus 16 Byte bestehen, habe ich recht.
meint sizeof(rx_buff) wird 16 Byte sein .. dh 2 Byte Ausrichtung am Ende
Michael Foukarakis
Die Antwort auf Ihre Frage ist nein. Das aligned Das Attribut ändert nicht die Größe der Variablen, auf die es angewendet wird, aber die Situation ist bei Strukturmitgliedern etwas anders. Um die zu zitieren Handbuch,
ausgerichtet (Ausrichtung)
Dieses Attribut gibt eine Mindestausrichtung für das Variablen- oder Strukturfeld an, gemessen in Byte. Zum Beispiel die Deklaration:
int x __attribute__ ((aligned (16))) = 0;bewirkt, dass der Compiler die globale Variable x einer 16-Byte-Grenze zuweist.
und,
verpackt
Das Attribut „packed“ gibt an, dass ein Variablen- oder Strukturfeld die kleinstmögliche Ausrichtung haben sollte – ein Byte für eine Variable und ein Bit für ein Feld, es sei denn, Sie geben mit dem Attribut „aligned“ einen größeren Wert an.
Hier ist eine Struktur, in der das Feld x so verpackt ist, dass es unmittelbar auf a folgt:
struct foo { char a; int x[2] __attribute__ ((packed)); };
Notiere dass der aligned Das Attribut kann das Speicherlayout von Strukturen ändern, indem es Padding zwischen Membern einfügt. Anschließend ändert sich die Größe der Struktur. Zum Beispiel:
struct t {
uint8_t a __attribute__((aligned(16))); /* one byte plus 15 as padding here */
uint16_t b __attribute__((aligned(16)));
};
würde zu 15 Byte Auffüllung danach führen a während die Standardausrichtung für die Zielarchitektur möglicherweise zu weniger geführt hätte. Wenn Sie die angegeben haben packed Attribut für die Struktur und verlor die aligned Attribute hätte die Struktur eine Größe von 3 Bytes. Hier ist eine Illustration, wie das Speicherlayout einer Struktur ist könnte jeweils aussehen.
struct t ohne Attribute und Standardausrichtung auf 8-Byte-Grenze:
+-+-------+--+-------+
|a| |bb| |
+-+-------+--+-------+
struct t wenn a und b an 16-Byte-Grenzen ausgerichtet sind:
+-+---------------+--+---------------+
|a| padding |bb| padding |
+-+---------------+--+---------------+
struct t wenn a und b keine Ausrichtungsbeschränkungen haben und t gepackt ist:
+-+--+
|a|bb|
+-+--+
Ihnen fehlt ein Ausrichtungseffekt – if a und b ausgerichtet sind, wird danach aufgefüllt b auch. Dies liegt an der Größe von struct t muss ein Vielfaches von 16 sein (andernfalls werden in einem Array die Felder des zweiten Elements falsch ausgerichtet).
– ugoren
15. Januar 2013 um 8:15 Uhr
Auch Polsterung wird hinzugefügt, wenn eine Struktur ausgerichtet ist: sagen wir struct foo {int a; int b;} und struct bar {int a; int b;} __attribute__((aligned(256))) wird unterschiedliche Größe haben. sizeof(struct foo) == 8 während sizeof(struct bar) == 256.
– Qwattasch
7. September 2017 um 15:06 Uhr
Das obige Array wird aus 16 Byte bestehen, habe ich recht.
Falsch. Das Array ist immer noch 14 Byte lang; das alles __attribute__((aligned)) bietet keine notwendige Polsterung außerhalb des Arrays um es an einer 8-Byte-Grenze auszurichten. Es ist unmöglich, mit Sicherheit etwas darüber anzunehmen, wo diese Polsterung vorhanden ist oder wie viel davon vorhanden ist.
Als solche, sizeof(rx_buf) bleibt 14, so wie es ohne die Angleichung gewesen wäre.
Um Ihre nicht gestellte Frage zu beantworten: Nein, Sie sollten (und das wird als schlechte Praxis angesehen) keine Strukturen auf die Festplatte kopieren oder sich auf die Speicherausrichtung verlassen, egal ob für den internen Gebrauch des Programms oder nicht.
– Dariusz
15. Januar 2013 um 7:31 Uhr