Warum ist sizeof für eine Struktur, die gleich der Summe der sizeof eines jeden Mitglieds?

Verpackung und byte-Ausrichtung, wie beschrieben in der C-FAQ hier:

Es ist für die Ausrichtung. Viele Prozessoren können nicht auf 2 - und 4-byte
Mengen (z.B. Ganzzahlen und lange Ganzzahlen), wenn Sie vollgestopft
jeden-welche-Weise.

Angenommen, Sie haben diese Struktur:

struct {
    char a[3];
    short int b;
    long int c;
    char d[3];
};

Nun werden Sie vielleicht denken, dass es sollte möglich sein, dieses pack
Struktur in Erinnerung wie dieses:

+-------+-------+-------+-------+
|           a           |   b   |
+-------+-------+-------+-------+
|   b   |           c           |
+-------+-------+-------+-------+
|   c   |           d           |
+-------+-------+-------+-------+

Aber es ist viel, viel einfacher auf dem Prozessor, wenn der compiler ordnet
es so:

+-------+-------+-------+
|           a           |
+-------+-------+-------+
|       b       |
+-------+-------+-------+-------+
|               c               |
+-------+-------+-------+-------+
|           d           |
+-------+-------+-------+

In der gepackten version, beachten Sie, wie es ist, zumindest ein bisschen hart für
Sie und mich, um zu sehen, wie die b-und c-Felder wrap-around? In einer nussschale,
es ist schwer für den Prozessor zu. Daher werden die meisten Compiler pad
die Struktur (als wenn mit zusätzliche, unsichtbare Felder) wie folgt:

+-------+-------+-------+-------+
|           a           | pad1  |
+-------+-------+-------+-------+
|       b       |     pad2      |
+-------+-------+-------+-------+
|               c               |
+-------+-------+-------+-------+
|           d           | pad3  |
+-------+-------+-------+-------+

InformationsquelleAutor EmmEff

Dies kann durch eine byte-Ausrichtung und Polsterung, so dass die Struktur kommt eine gerade Anzahl von bytes (oder Worten) auf Ihrer Plattform. Zum Beispiel in C auf Linux, die folgenden 3 Strukturen:

#include "stdio.h"


struct oneInt {
  int x;
};

struct twoInts {
  int x;
  int y;
};

struct someBits {
  int x:2;
  int y:6;
};


int main (int argc, char** argv) {
  printf("oneInt=%zu\n",sizeof(struct oneInt));
  printf("twoInts=%zu\n",sizeof(struct twoInts));
  printf("someBits=%zu\n",sizeof(struct someBits));
  return 0;
}

Haben Mitglieder, die die Größe (in bytes) 4 bytes (32 bits) 8 bytes (2x 32 bit) und 1 byte (2+6 bit) bzw. Das obige Programm (unter Linux mit gcc) druckt den Größen 4, 8, 4, wo die Letzte Struktur ist gepolstert, so dass es ein einzelnes Wort ist (4 x 8-bit-bytes, die auf meinem 32bit-Plattform).

oneInt=4
twoInts=8
someBits=4

InformationsquelleAutor Kyle Burton

Die Größe einer Struktur ist mehr als die Summe seiner Teile, weil, was heißt Verpackung. Ein Prozessor hat eine bevorzugte Größe der Daten, dass es funktioniert. Die meisten modernen Prozessoren " bevorzugte Größe, wenn 32-bit (4 bytes). Zugriff auf den Speicher, wenn die Daten auf diese Art der Grenze ist effizienter als die Dinge, die Spagat, die Größe-Grenze.

Zum Beispiel. Betrachten Sie die einfache Struktur:

struct myStruct
{
   int a;
   char b;
   int c;
} data;

Wenn die Maschine eine 32-bit-Maschine und Daten ausgerichtet ist, auf einem 32-bit-Grenze, sehen wir ein unmittelbares problem (vorausgesetzt, dass kein Struktur-alignment). In diesem Beispiel lassen Sie uns annehmen, dass die Struktur der Daten beginnt bei der Adresse 1024 (0 x 400 - beachten Sie, dass die niedrigsten 2 bits null sind, also die Daten, die ausgerichtet ist, um eine 32-bit-Grenze). Der Zugriff auf die Daten.einer wird funktionieren, weil Sie beginnt, auf eine Grenze - 0 x 400. Der Zugriff auf die Daten.b wird auch funktionieren, weil es unter der Adresse 0x404 - andere 32-bit-Grenze. Aber einen nichtlinearen Struktur würde Daten.c an der Adresse 0x405. Die 4 bytes der Daten.c sind 0x405, 0x406, 0x407, 0x408. Auf einem 32-bit-Maschine, würde das system die Daten Lesen.c während ein Speicher-Zyklus, würde aber nur 3 der 4 Byte (das 4. byte ist die nächste Grenze). So würde das system um einen zweiten Zugang zum Speicher zu erhalten, das 4. byte,

Nun, wenn, anstatt Daten.c an der Adresse 0x405, der compiler gepolsterte die Struktur von 3 bytes und die Daten.c an der Adresse 0x408, dann würde das system nur noch 1 Zyklus, um Daten zu Lesen, schneiden Zugriffszeit auf die Daten-element um 50%. Polsterung swaps Speicher-Wirkungsgrad für die Effizienz der Verarbeitung. Da Computer können riesige Mengen an Speicher (viele Gigabyte), wird der Compiler das Gefühl, dass die swap - (speed over size) vernünftig.

Leider, dieses problem wird ein killer, wenn Sie versuchen zu senden-Strukturen über ein Netzwerk oder sogar das schreiben der binären Daten in einer binary-Datei. Die Polsterung eingefügt zwischen den Elementen einer Struktur oder Klasse zerstören kann, die Daten gesendet zu der Datei oder dem Netzwerk. Um write portable code (eine, die gehen, um verschiedene Compiler), werden Sie wahrscheinlich haben, um Zugriff auf jedes element der Struktur einzeln, um sicherzustellen, dass die richtige "Verpackung".

Auf der anderen Seite, verschiedene Compiler besitzen verschiedene Fähigkeiten, die zum verwalten von Daten Struktur-Verpackung. Zum Beispiel in Visual C/C++ - compiler unterstützt die #pragma pack Befehl. Dies ermöglicht es Ihnen, Daten anpassen Verpackung und Ausrichtung.

Beispiel:

#pragma pack 1
struct MyStruct
{
    int a;
    char b;
    int c;
    short d;
} myData;

I = sizeof(myData);

Ich soll jetzt die Länge von 11. Ohne das pragma, ich könnte alles sein, von 11 bis 14 (und für einige Systeme, so viel wie 32), abhängig von der Standard-Verpackung der compiler.

InformationsquelleAutor sid1138

C99 N1256 standard-Entwurf

http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf

6.5.3.4 Den sizeof-operator:

3 angewandt auf einen Operanden, der hat die Struktur-oder union-Typ,
das Ergebnis ist die Gesamtzahl der bytes, die in einem solchen Objekt,
einschließlich der internen und nachgestellte Leerstellen.

6.7.2.1 Struktur-und union-Bezeichner:

13 ... kann Es sein, Unbenannte
padding innerhalb einer Struktur Objekt, aber nicht an seinem Anfang.

und:

15 Es kann Unbenannte Polsterung am Ende einer Struktur oder union.

Dem neuen C99 - flexible array-member-Funktion ( struct S {int is[];}; ) kann auch beeinflussen Polsterung:

16 Als ein besonderer Fall, wird das Letzte element einer Struktur mit mehr als einem benannten Mitglied kann
haben einen unvollständigen array-Typ; dies wird als eine flexible array-member. In den meisten Situationen,
die flexible array-member wird ignoriert. Insbesondere die Größe der Struktur ist, als ob die
flexible array-member wurden weggelassen, außer, dass es möglicherweise weitere nachfolgende Polsterung als
der Wegfall würde bedeuten.

Anhang J portabilitätsprobleme bekräftigt:

Den folgenden unspezifisch sind: ...

• Den Wert von padding-bytes beim speichern von Werten in den Strukturen oder unions (6.2.6.1)

C++11 N3337 standard-Entwurf

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf

5.3.3 Sizeof:

2, Wenn angewandt
zu einer Klasse, das Ergebnis ist die Anzahl der bytes, die in ein Objekt der Klasse einschließlich Polsterung erforderlich
platzieren Sie Objekte eines Typs in einem array.

9.2 die Schüler:

Einen Zeiger auf ein standard-layout struct-Objekt, entsprechend konvertiert mit einem reinterpret_cast, Punkte zu seinen
Gründungsmitglied (oder, wenn das Mitglied ist eine bit-Feld, dann auf die Einheit, in der es sich befindet) und Umgekehrt. [ Hinweis:
Es könnte daher sein, Unbenannte Polsterung in einem standard-layout-struct-Objekt, aber nicht am Anfang
wie nötig, um eine angemessene Ausrichtung. — Ende Hinweis ]

Ich kenne nur genug C++ zu verstehen, den Hinweis 🙂

InformationsquelleAutor Ciro Santilli 新疆改造中心996ICU六四事件

C-Sprache lässt compiler einige Freiheit über die Lage, die strukturellen Elemente in den Speicher:

• memory Löcher erscheinen können zwischen zwei beliebigen Komponenten, und nach der letzten Komponente. Es war aufgrund der Tatsache, dass bestimmte Arten von Objekten auf dem Ziel-computer ist begrenzt durch die Grenzen der Adressierung
• "memory holes" Größe enthalten, die in das Ergebnis der sizeof-operator. Der sizeof nur nicht schließen Größe der flexiblen Arrays, die in C/C++
• Einige Implementierungen der Sprache ermöglichen die Steuerung der Speicher-layout von Strukturen, durch die pragma-und compiler-Optionen

Die C-Sprache bietet eine gewisse Sicherheit für den Programmierer, der die layout-Elemente in der Struktur:

• - Compiler erforderlich, um ordnen Sie eine Folge von Komponenten, die mehr Speicher-Adressen
• Adresse der ersten Komponente fällt mit der Startadresse der Struktur
• Unbenannte Bitfelder können in der Struktur enthalten, um die benötigte Adresse Ausrichtungen der angrenzenden Elemente

Probleme im Zusammenhang mit den Elementen Ausrichtung:

• Verschiedenen Computern Linie die Kanten von Objekten in unterschiedlicher Weise
• Verschiedene Einschränkungen auf die Breite des bit-Feld
• Computer unterscheiden sich, wie zum speichern der bytes in einem Wort (Intel 80x86 sowie Motorola 68000)

, Wie die Ausrichtung funktioniert:

• Des Umfangs, der Struktur errechnet sich die Größe des ausgerichteten einzelnes element in ein array solcher Strukturen. Die Struktur sollte
  Ende, so dass das erste element des als Nächstes folgenden Struktur nicht gegen die Anforderungen der Ausrichtung

p.s genauere Infos gibt es hier: "Samuel P. Harbison, Guy L. Steele C-A Reference, (5.6.2 - 5.6.7)"

InformationsquelleAutor bruziuz