Verwende die einfachste und verständlichste Methode, um die Größe eines Structs zu berechnen.

Die Berechnung der Struct-Größe muss dem Prinzip der Byte-Ausrichtung folgen.

Standardmäßig erfüllt die Byte-Ausrichtung von Structs im Allgemeinen drei Regeln:

  • 1) Die erste Adresse einer Struct-Variablen muss durch die Größe ihres breitesten Grundtyp-Mitglieds teilbar sein;
  • 2) Der Offset jedes Mitglieds relativ zur ersten Adresse des Structs ist ein ganzzahliges Vielfaches der Größe des Mitglieds; falls nötig, fügt der Compiler Auffüllbytes zwischen den Mitgliedern hinzu (internes Auffüllen);
  • 3) Die Gesamtgröße des Structs ist ein ganzzahliges Vielfaches der Größe seines breitesten Grundtyp-Mitglieds; falls nötig, fügt der Compiler nach dem letzten Mitglied Auffüllbytes hinzu (nachfolgendes Auffüllen).

Eigentlich ignoriere vorerst diese drei Regeln. Meine Methode erfordert nur, sich die dritte zu merken: Die Struct-Größe muss ein ganzzahliges Vielfaches der größten Byte-Größe unter ihren Mitgliedern sein.

Sieh dir zuerst die beiden unten definierten Structs an:

struct {   char a;   short b;   char c; }S1;

struct {  char  a;  char  b;  short c; }S2;

Jeweils durch Programmtest ermittelt:sizeof(S1)=6 , sizeof(S2)=4。

Hinweis: Warum erzeugt allein das Ändern der Reihenfolge der Struct-Mitglieder unterschiedliche Ergebnisse?

Lösung:

  • (1) Finde zuerst die größte Byte-Größe unter den Mitgliedsvariablen. Man sieht, dass für S1 und S2 short am größten ist, was 2 Bytes belegt;
  • (2) Daher werden ab jetzt 2 Bytes als Standard verwendet. Das heißt, jedes Member benötigt höchstens 2 Bytes, und der Rest wird als Platzhalter aufgefüllt. Beachten Sie, dass im folgenden Diagramm ein Kästchen ein Byte darstellt;
  • (3) Also zeichnen Sie zuerst 2 Kästchen, dann schauen Sie sich die Member-Reihenfolge an und erhöhen Sie Schritt für Schritt, wobei 2 jeweils als Inkrementbasis dient.
Für S1 lautet die Reihenfolgechar->short->char :

Für S1 beträgt die struct-Größe also 2*3=6. Warum das zusätzliche Byte des zweiten char nicht verworfen wird, folgt der dritten Regel: Die struct-Größe muss ein ganzzahliges Vielfaches der größten Bytegröße unter den Membern sein.

S1=2*3=6

Für S2 zeichnen Sie ebenfalls ein Diagramm; die Reihenfolge istchar->char->short：

S2=2*2=4

Betrachten Sie mit dieser Methode eine weitere struct wie diese:

struct stu1
{
    int i;
    char c;
    int j;
};

Offensichtlich ist die größte Bytegröße 4. Reihenfolge: int char int:

Da int 4 Bytes belegt und char bereits 1 belegt, was nicht ausreicht, müssen diese 3 Bytes zusätzliche Platzhalter sein.

Stu1=3*4=12

Was ist, wenn wir es ändern?

struct stu2
{
    int i;
    int j;
    char  c；
}；
Stu2=3*4=12

Betrachten Sie ein weiteres: Wenn eine Member-Variable einer struct eine andere struct ist, fügen Sie die Member-struct einfach als Ganzes hinzu.

typedef struct A
{
    char a1;
    short int a2;
    int a3;
    double d;
};

A=16

typedef struct B
{
    long int b2;
    short int b1;
    A a;
};

Für B ignorieren Sie zunächst A a, das heißt, entfernen Sie das Member A a und berechnen Sie die Größe von struct B als 8, sodass das Endergebnis 8+16=24 ist; 24 ist das Endergebnis.

Originaladresse: https://www.cnblogs.com/lykbk/archive/2013/04/02/krtmbhrkhoirtj9468945.html