C Struktur

C-Arrays ermöglichen das Definieren von Variablen, die Datenelemente desselben Typs speichern können, undStrukturensind ein weiterer benutzerdefinierter Datentyp, der in der C-Programmierung verfügbar ist und es ermöglicht, Datenelemente unterschiedlicher Typen zu speichern.

Datenelemente in einer Struktur können grundlegende Datentypen (wie int, float, char usw.) oder andere Strukturtypen, Zeigertypen und so weiter sein.

Strukturen werden verwendet, um einen Datensatz darzustellen. Angenommen, Sie möchten die Dynamik von Büchern in einer Bibliothek verfolgen; möglicherweise müssen Sie die folgenden Attribute für jedes Buch verfolgen:

  • Title
  • Autor
  • Thema
  • Buch-ID

Struktur definieren

Die Strukturdefinition besteht aus dem Schlüsselwortstructund dem Strukturnamen. Der Strukturname kann nach Bedarf definiert werden.

Die struct-Anweisung definiert einen neuen Datentyp, der mehrere Member enthält. Das Format der struct-Anweisung ist wie folgt:

struct Tag {
    Member--Liste
    Member--Liste
    Member--Liste  
    ...
} Variablen-liste ;

TagIst ein struct-Tag.

member-listist eine Standardvariablendefinition, wieint i;oderfloat f;, oder andere gültige Variablendefinitionen.

variable-listStrukturvariablen, definiert am Ende der Struktur, vor dem abschließenden Semikolon; Sie können eine oder mehrere Strukturvariablen angeben. Im Folgenden wird gezeigt, wie eine Book-Struktur deklariert wird:

struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book;  

Im Allgemeinen,tag、member-list、variable-listMindestens 2 dieser 3 Teile müssen vorkommen. Das Folgende ist ein Beispiel:

// Diese Deklaration deklariert eine Struktur mit 3 Membern, nämlich Ganzzahl a, Zeichen b und double c
// Außerdem deklariert sie die Strukturvariable s1
// Diese Struktur spezifiziert ihren Tag nicht
struct
{
    int a;
    char b;
    double c;
} s1;

// Diese Deklaration deklariert eine Struktur mit 3 Membern, nämlich Ganzzahl a, Zeichen b und double c
// Der Tag der Struktur heißt SIMPLE, und es wird keine Variable deklariert
struct SIMPLE
{
    int a;
    char b;
    double c;
};
// Unter Verwendung der Struktur mit dem Tag SIMPLE werden zusätzliche Variablen t1, t2, t3 deklariert
struct SIMPLE t1, t2[20], *t3;

// Sie können auch typedef verwenden, um einen neuen Typ zu erstellen
typedef struct
{
    int a;
    char b;
    double c;
} Simple2;
// Jetzt kann Simple2 als Typ verwendet werden, um neue Strukturvariablen zu deklarieren
Simple2 u1, u2[20], *u3;

In den obigen Deklarationen werden die erste und zweite Deklaration vom Compiler als zwei völlig unterschiedliche Typen behandelt, selbst wenn ihre Member-Listen gleich sind. Wenn Sie t3=&s1 setzen, ist es unzulässig.

Member einer Struktur können andere Strukturen enthalten und auch Zeiger auf ihren eigenen Strukturtyp enthalten. Normalerweise werden solche Zeiger verwendet, um fortgeschrittenere Datenstrukturen wie verkettete Listen und Bäume zu implementieren.

// Diese Strukturdeklaration enthält andere Strukturen
struct COMPLEX
{
    char string[100];
    struct SIMPLE a;
};

// Diese Strukturdeklaration enthält einen Zeiger auf ihren eigenen Typ
struct NODE
{
    char string[100];
    struct NODE *next_node;
};

Wenn zwei Strukturen einander enthalten, benötigt eine der Strukturen eine unvollständige Deklaration, wie unten gezeigt:

struct B;    // Eine unvollständige Deklaration von Struktur B vornehmen

// struct A enthält einen Zeiger auf struct B
struct A
{
    struct B *partner;
    //weitere Member;
};

// struct B enthält einen Zeiger auf struct A; nach der Deklaration von A wird auch B deklariert.
struct B
{
    struct A *partner;
    //weitere Member;
};

Initialisierung von Strukturvariablen

Wie Variablen anderer Typen können Strukturvariablen zum Zeitpunkt der Definition mit Anfangswerten versehen werden.

Beispiel

#include <stdio.h>

struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book = {"C language", "EXAMPLE", "programming language", 123456};

int main()
{
    printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
}

Die Ausgabe nach der Ausführung ist:

title : C 语言
author: EXAMPLE
subject: 编程语言
book_id: 123456

Zugriff auf Strukturmitglieder

Um auf die Mitglieder einer Struktur zuzugreifen, verwenden wirMitgliedszugriffsoperator (.)Der Mitgliedszugriffsoperator ist ein Punkt zwischen dem Namen der Strukturvariablen und dem Strukturmitglied, auf das wir zugreifen möchten. Sie können das Schlüsselwortstructverwenden, um Variablen vom Typ Struktur zu definieren. Das folgende Beispiel demonstriert die Verwendung von Strukturen:

Beispiel

#include <stdio.h>
#include <string.h>
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};
 
int main( )
{
   struct Books Book1;        /* Book1 vom Typ Books deklarieren */
   struct Books Book2;        /* Book2 vom Typ Books deklarieren */
 
   /* Details zu Book1 */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali");
   strcpy( Book1.subject, "C Programming Tutorial");
   Book1.book_id = 6495407;

   /* Details zu Book2 */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");
   Book2.book_id = 6495700;
 
   /* Book1-Informationen ausgeben */
   printf( "Buch 1 Titel : %s\n", Book1.title);
   printf( "Buch 1 Autor : %s\n", Book1.author);
   printf( "Buch 1 Thema : %s\n", Book1.subject);
   printf( "Buch 1 book_id : %d\n", Book1.book_id);

   /* Book2-Informationen ausgeben */
   printf( "Buch 2 Titel : %s\n", Book2.title);
   printf( "Buch 2 Autor : %s\n", Book2.author);
   printf( "Buch 2 Thema : %s\n", Book2.subject);
   printf( "Buch 2 book_id : %d\n", Book2.book_id);

   return 0;
}

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

Strukturen als Funktionsparameter

Sie können Strukturen als Funktionsparameter übergeben, und die Übergabe erfolgt ähnlich wie bei Variablen oder Zeigern anderer Typen. Sie können die Methode im obigen Beispiel verwenden, um auf Strukturvariablen zuzugreifen:

Beispiel

#include <stdio.h>
#include <string.h>
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};

/* Funktionsdeklaration */
void⟦printBook printBook( struct Book book );
int main( )
{
   struct Books Book1;        /* Book1 vom Typ Books deklarieren */
   struct Books Book2;        /* Book2 vom Typ Books deklarieren */
 
   /* Details zu Book1 */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali");
   strcpy( Book1.subject, "C Programming Tutorial");
   Book1.book_id = 6495407;

   /* Details zu Book2 */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");
   Book2.book_id = 6495700;
 
   /* Book1-Informationen ausgeben */
   printBook( Book1 );

   /* Book2-Informationen ausgeben */
   printBook( Book2 );

   return 0;
}
void⟦printBook printBook( struct Book book )
{
   printf( "Buchtitel : %s\n", book.title);
   printf( "Buchautor : %s\n", book.author);
   printf( "Buchthema : %s\n", book.subject);
   printf( "Buch book_id : %s\n", book.book);
}

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

Book title : C Programming
Book author : Nuha Ali
Book subject : C Programming Tutorial
Book book_id : 6495407
Book title : Telecom Billing
Book author : Zara Ali
Book subject : Telecom Billing Tutorial
Book book_id : 6495700

Zeiger⟦

Sie können einen Zeiger auf eine Struktur auf ähnliche Weise definieren wie Zeiger auf Variablen anderer Typen, wie unten gezeigt:

struct Books *struct_pointer;

Jetzt können Sie die Adresse einer Strukturvariablen in der oben definierten Zeigervariablen speichern. Um die Adresse einer Strukturvariablen zu finden, setzen Sie den &-Operator vor den Strukturnamen, wie unten gezeigt:

struct_pointer = &Book1;

Um auf Mitglieder der Struktur über einen Zeiger auf die Struktur zuzugreifen, müssen Sie den ->-Operator verwenden, wie unten gezeigt:

struct_pointer->title;

Lassen Sie uns das obige Beispiel mit Strukturzeigern neu schreiben, was Ihnen helfen wird, das Konzept der Strukturzeiger zu verstehen:

Beispiel

#include <stdio.h>
#include <string.h>
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};

/* Funktionsdeklaration */
void printBook( struct Books *book );
int main( )
{
   struct Books Book1;        /* Book1 vom Typ Books deklarieren */
   struct Books Book2;        /* Book2 vom Typ Books deklarieren */
 
   /* Details zu Book1 */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali");
   strcpy( Book1.subject, "C Programming Tutorial");
   Book1.book_id = 6495407;

   /* Details zu Book2 */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");
   Book2.book_id = 6495700;
 
   /* Book1-Informationen durch Übergeben der Adresse von Book1 ausgeben */
   printBook( &Book1 );

   /* Book2-Informationen durch Übergeben der Adresse von Book2 ausgeben */
   printBook( &Book2 );

   return 0;
}
void printBook( struct Books *book )
{
   printf( "Buchtitel : %s\n", book->title);
   printf( "Buchautor : %s\n", book->author);
   printf( "Buchthema : %s\n", book->subject);
   printf( "Buch book_id : %d\n", book->book_id);
}

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

Book title : C Programming
Book author : Nuha Ali
Book subject : C Programming Tutorial
Book book_id : 6495407
Book title : Telecom Billing
Book author : Zara Ali
Book subject : Telecom Billing Tutorial
Book book_id : 6495700

Berechnung der Strukturgröße

In der Sprache C können wirsizeofals Operator verwenden, um die Größe einer Struktur zu berechnen,sizeofgibt die Byte-Größe des angegebenen Typs oder der angegebenen Variable zurück.

Für Strukturen gibtsizeofdie Gesamtzahl der Bytes der Struktur zurück, einschließlich der Größen aller Membervariablen und möglicher Padding-Bytes.

Das folgende Beispiel zeigt, wie man die Größe einer Struktur berechnet:

Beispiel

#include <stdio.h>

struct Person {
    char name[20];
    int age;
    float height;
};

int main() {
    struct Person person;
    printf("Größe von struct Person: %zu Bytes\n", sizeof(person));
    return 0;
}

Im obigen Beispiel haben wir eine Struktur namensPersonEine Struktur, die ein Zeichenarray enthält:name, eine Ganzzahlageund eine Fließkommazahlheight。

InmainIn der Funktion haben wir einePersonVariable vom Typperson deklariert, dann verwenden wir densizeofOperator, um vonpersondie Größe der Struktur zu erhalten.

Schließlich verwenden wirprintfDie Funktion gibt die Größe der Struktur aus, und die Ausgabe sieht wie folgt aus:

结构体 Person 大小为: 28 字节

Hinweis: Die Größe einer Struktur kann durch die Optimierungs- und Ausrichtungsregeln des Compilers beeinflusst werden. Der Compiler kann zusätzliche Füllbytes in die Struktur einfügen, um die Member-Variablen der Struktur auszurichten, was die Speicherzugriffseffizienz verbessert. Daher kann die tatsächliche Größe der Struktur größer sein als die Summe der Größen der Member-Variablen. Wenn Sie das Speicherlayout und die Ausrichtung der Struktur genau kennen müssen, können SieoffsetofMakro und__attribute__((packed))Attribute und so weiter, um die Größe und Ausrichtung der Struktur weiter zu steuern und abzufragen.

Weitere Erweiterungen