In diesem Artikel haben wir erklärt, wie man die Speichergröße einer Struktur in der Programmiersprache C und C++ berechnet . Um die tatsächliche Größe zu ermitteln, müssen Sie zwei Konzepte der Polsterung und Verpackung verstehen. Die Größe ist nicht die Summe der einzelnen Elemente, also lesen Sie weiter.

Inhaltsverzeichnis:

1. Strukturpolsterung
2. Strukturpackung

Lassen Sie uns die Ideen mit Codebeispielen und Erläuterungen erkunden.

Strukturauffüllung

Computer speichert die Struktur unter Verwendung des Konzepts der Wortgrenze.
Die Größe einer Wortgrenze ist maschinenabhängig. In einem Computer mit zwei Bytes Wortgrenze werden die Mitglieder einer Struktur left_aligned auf der Wortgrenze gespeichert.

Der Prozessor liest nicht jeweils 1 Byte aus dem Speicher. Er liest jeweils 1 Wort.
In einem 32-Bit-Prozessor kann er auf 4 Bytes gleichzeitig zugreifen, was bedeutet, dass die Wortgröße 4 Bytes beträgt.
In ähnlicher Weise kann ein 64-Bit-Prozessor auf 8 Bytes gleichzeitig zugreifen, was bedeutet, dass die Wortgröße 8 Bytes beträgt.

Was wir wissen, ist, dass die Größe einer Struktur die Summe aller Datenelemente ist. Wie für die folgende Struktur,

struct A{
    int n1;
    int* n2;
    char c1;
    char *c2;
};

Die Größe der Struktur sollte die Summe aller Datenelemente sein, also:Größe von int n1+ Größe von int* n2 + Größe von char c1+ Größe von char* c2

Betrachten wir nun das 64-Bit-System,
Die Größe von int beträgt 4 Bytes
Die Zeichengröße beträgt 1 Byte
Die Größe jedes Zeigertyps beträgt 8 Bytes
(Die Zeigergröße hängt auch nicht davon ab, auf welche Art von Datentyp sie zeigen)

Die Größe des Structs sollte also sein:(4+8+1+8)=21 Bytes

Mal sehen, was der Compiler mit dem Operator sizeof() ausgibt.

#include <stdio.h>

struct ABC {
    int n1;
    int* n2;
    char c1;
    char* c2;
};

int main()
{
    struct ABC a;
    printf("Size of struct ABC: %lu\n", sizeof(struct ABC));
    printf("Size of object a: %lu\n", sizeof(a));
    return 0;
}

Die Ausgabe des obigen Programms ist:
Größe der Struktur ABC:32
Größe von Objekt a:32

Es scheint, als hätte der Compiler die maximale Größe aus dem Datentyp genommen und allen Datentypen denselben Speicher zugewiesen.
Es richtet sich bis zur Grenze des maximal zugewiesenen Speichers aus. Hier stellen wir fest, dass der maximal zugewiesene Speicher 8 Bytes beträgt, daher erfassen alle Datenelemente 8 Bytes und die Gesamtgröße beträgt 32 Bytes.

Ist es wie die Anzahl der Datenelemente * maximale Datentypgröße?
Die Antwort ist nein. Überprüfen Sie die folgende Struktur, die dieselben Mitglieder hat, aber die Reihenfolge ist unterschiedlich.

struct B{
    int* b;
    char c;
    int a;
    char *d;
};

Betrachten Sie dieses C-Codebeispiel:

#include <stdio.h>

struct BAC {
    int* n2;
    char c1;
    int n1;
    char* c2;
};

int main()
{
    struct BAC b;
    printf("Size of struct BAC: %lu\n", sizeof(struct BAC));
    printf("Size of object b: %lu\n", sizeof(b));
    return 0;
}

Die Ausgabe des obigen Programms ist:
Größe der Struktur BAC:24
Größe von Objekt b:24

Der Compiler richtet gierig weiter aus und deshalb hat er char c &int a in derselben Zeile ausgerichtet. Als es versuchte, char* d auszurichten, konnte es nicht, da nur 3 Bytes übrig waren. Aber anstelle von char*, wenn es nur char wäre, wäre es in der gleichen Zeile ausgerichtet worden.

Wenn wir Strukturvariablen deklarieren, kann jede von ihnen Slack-Bytes enthalten, und die in solchen Slack-Bytes gespeicherten Werte sind undefiniert. Aus diesem Grund sind, selbst wenn die Elemente zweier Variablen gleich sind, ihre Strukturen nicht unbedingt gleich.

C erlaubt daher keinen Vergleich von Strukturen.

Strukturpacken

Wir können die Verschwendung von Speicher vermeiden, indem wir einfach #pragma pack(1)

#pragma pack(1)

#pragma

#pragma ist eine spezielle Direktive, die verwendet wird, um bestimmte Funktionen ein- oder auszuschalten.

#include <stdio.h>
#pragma pack(1)
struct ABC {
    char a;
    int b;
    char c;
};

int main()
{
    printf("Size of struct ABC: %lu\n", sizeof(struct ABC));
    return 0;
}

Die Ausgabe des obigen Programms ist:
Größe der Struktur ABC:6
Da int 4 Byte benötigt und eine zweistellige Variable jeweils 1 Byte benötigt.

Sehen wir uns nun einige Fragen zu diesem Thema an.

Frage 1

Welche Direktive wird für das Strukturpacken verwendet?

struct BAC {
    char c;
    int n;
    char b;
};

Frage 2

Wie groß ist die obige Struktur?

Mit diesem Artikel bei OpenGenus müssen Sie die vollständige Vorstellung davon haben, wie die Größe einer Struktur (Struct) in C und C++ berechnet wird.