C++ Structs erklärt mit praktischem Beispiel

Was ist ein Struct in C++?

Ein STRUCT ist eine C++‑Datenstruktur, die Elemente unterschiedlicher Datentypen zusammenfasst. In C++ ist eine Struktur ein benutzerdefinierter Datentyp. Die Struktur erstellt einen Datentyp, um Elemente verschiedener Typen unter einem einzigen Typ zu gruppieren.

Beispiel:

Angenommen, Sie müssen Informationen über eine Person speichern: Name, Staatsangehörigkeit und Alter. Sie könnten Variablen name, citizenship, age separat anlegen.

Später müssen Sie vielleicht Daten vieler Personen speichern. Dann würden Sie Variablen wie name1, citizenship1, age1 usw. erstellen. Um dies zu vermeiden, erstellt man besser ein Struct.

In diesem C++‑Tutorial lernen Sie:

• Was ein Struct in C++ ist
• Wann man eine Struktur verwendet
• C++ Struct‑Initialisierung
• Struct‑Instanzen erzeugen
• Auf Struct‑Member zugreifen
• Zeiger auf Strukturen
• Struct als Funktionsargument
• Einschränkungen einer C++‑Struktur

Wann eine Struktur verwenden?

Gründe für den Einsatz von Strukturen in C++:

• Nutzen Sie ein Struct, wenn Sie Elemente verschiedener Datentypen unter einem Datentyp speichern müssen.
• C++‑Structs sind Werttypen, keine Referenztypen. Verwenden Sie ein Struct, wenn Sie die Daten nach Erstellung nicht ändern möchten.

C++ Struct‑Initialisierung

Um eine C++‑Struktur zu erstellen, verwendet man das Schlüsselwort struct, gefolgt von einem Bezeichner. Der Bezeichner wird zum Namen des Structs. Hier ist die Syntax:

Syntax:

struct struct_name {
    // struct‑member
}

In der obigen Syntax wird das Schlüsselwort struct verwendet. struct_name ist der Name der Struktur.

Die Struct‑Member stehen in geschweiften Klammern. Diese Member gehören vermutlich unterschiedlichen Datentypen an.

Beispiel:

struct Person {
    char name[30];
    int citizenship;
    int age;
}

Im obigen Beispiel ist Person eine Struktur mit drei Membern: name, citizenship, age. Ein Member ist vom Typ char, die anderen beiden sind Integer. Beim Erstellen einer Struktur wird noch kein Speicher allokiert. Speicher wird erst reserviert, wenn eine Variable des Struct‑Typs angelegt wird.

Struct‑Instanzen erzeugen

Im obigen Beispiel haben wir ein Struct namens Person erstellt. Eine Struct‑Variable kann wie folgt erzeugt werden:

Person p;

p ist eine Struct‑Variable vom Typ Person. Mit dieser Variable können wir auf die Member der Struktur zugreifen.

Auf Struct‑Member zugreifen

Für den Zugriff auf Struct‑Member nutzt man die Instanz und den Punkt‑Operator (.). Beispiel: Zugriff auf Member age von Struct Person:

p.age = 27;

Wir haben den Member age über die Instanz p angesprochen und seinen Wert auf 27 gesetzt.

Beispiel 1:

#include <iostream>
using namespace std;
struct Person {
    int citizenship;
    int age;
};
int main(void) {
    struct Person p;
    p.citizenship = 1;
    p.age = 27;
    cout << "Person citizenship: " << p.citizenship << endl;
    cout << "Person age: " << p.age << endl;
    return 0;
}

Ausgabe:

Screenshot des Codes:

Code‑Erklärung:

1. iostream Header einbinden.
2. std‑Namespace nutzen.
3. Struct Person erstellen.
4. Beginn des Struct‑Bodys.
5. Member citizenship vom Typ Integer anlegen.
6. Member age vom Typ Integer anlegen.
7. Ende des Struct‑Bodys.
8. main() aufrufen; Programmlogik in Funktionskörper.
9. Instanz p vom Struct Person erzeugen.
10. Member citizenship auf 1 setzen.
11. Member age auf 27 setzen.
12. Wert von citizenship mit Text ausgeben.
13. Wert von age mit Text ausgeben.
14. Programm gibt bei Erfolg Wert zurück.
15. Ende von main().

Zeiger auf Strukturen

Es ist möglich, einen Zeiger zu erstellen, der auf eine Struktur zeigt. Dies funktioniert analog zu Zeigern auf native Datentypen wie int, float, double etc. Beachten Sie, dass ein Zeiger in C++ eine Speicheradresse speichert.

Beispiel 2:

#include <iostream>
using namespace std;
struct Length {
    int meters;
    float centimeters;
};
int main() {
    Length *ptr, l;
    ptr = &l;
    cout << "Meter eingeben: ";
    cin >> (*ptr).meters;
    cout << "Zentimeter eingeben: ";
    cin >> (*ptr).centimeters;
    cout << "Länge = " << (*ptr).meters << " Meter " << (*ptr).centimeters << " Zentimeter";
    return 0;
}

Ausgabe:

Screenshot des Codes:

Code‑Erklärung:

1. iostream Header einbinden.
2. std‑Namespace nutzen.
3. Struct Length erstellen.
4. Beginn des Struct‑Bodys.
5. Member meters als Integer.
6. Member centimeters als Float.
7. Ende des Struct‑Bodys.
8. main() aufrufen.
9. Beginn des main()‑Bodys.
10. Zeigervariable *ptr und normale Variable l vom Typ Length anlegen.
11. Adresse von l in ptr speichern.
12. Aufforderung zur Eingabe von meters.
13. Eingabe lesen; Member meters über Zeiger zugreifen.
14. Aufforderung zur Eingabe von centimeters.
15. Eingabe lesen; Member centimeters über Zeiger zugreifen.
16. Eingelesene Werte mit Text ausgeben.
17. Programm gibt bei Erfolg Wert zurück.
18. Ende von main().

Struct als Funktionsargument

Man kann ein Struct als Argument an eine Funktion übergeben. Dies geschieht genauso wie bei normalen Argumenten. Struct‑Variablen können ebenfalls übergeben werden. Ein gutes Beispiel ist die Anzeige von Struct‑Member‑Werten. Lassen Sie uns dies demonstrieren:

Beispiel 3:

#include <iostream>
using namespace std;
struct Person {
    int citizenship;
    int age;
};
void func(struct Person p);
int main() {
    struct Person p;
    p.citizenship = 1;
    p.age = 27;
    func(p);
    return 0;
}
void func(struct Person p) {
    cout << " Person citizenship: " << p.citizenship << endl;
    cout << " Person age: " << p.age;
}

Ausgabe:

Screenshot des Codes:

Code‑Erklärung:

1. iostream Header einbinden.
2. std‑Namespace nutzen.
3. Struct Person erstellen.
4. Beginn des Struct‑Bodys.
5. Member citizenship (Integer).
6. Member age (Integer).
7. Ende des Struct‑Bodys.
8. Funktion func deklarieren, die Instanz p als Argument nimmt.
9. main() aufrufen.
10. Instanz p von Person erzeugen.
11. Member citizenship über p auf 1 setzen.
12. Member age über p auf 27 setzen.
13. func aufrufen und p übergeben.
14. Funktion gibt bei Erfolg Wert zurück.
15. Ende von main().
16. Funktionsbody func erstellen.
17. Beginn des Funktionsbodys.
18. Member citizenship ausgeben.
19. Member age ausgeben.
20. Ende des Funktionsbodys.

Einschränkungen einer C++‑Struktur

Folgende Limitationen bestehen:

• Der Struct‑Datentyp kann nicht wie eingebaute Datentypen behandelt werden.
• Operatoren wie +, - etc. können nicht auf Strukturvariablen angewendet werden.
• Strukturen unterstützen keine Datenkapselung. Member sind von jeder Funktion zugänglich, unabhängig vom Gültigkeitsbereich.
• Statische Member können nicht im Struct‑Body deklariert werden.
• Konstruktoren können nicht innerhalb einer Struktur erstellt werden.

Zusammenfassung:

• Ein Struct fasst Datenelemente verschiedener Typen zusammen.
• Während ein Array Elemente gleichen Typs speichert, speichert ein Struct Elemente unterschiedlichen Typs.
• Ein Struct sollte verwendet werden, wenn sich die Datenelemente nicht ändern sollen.
• Member eines Structs werden über den Punkt‑Operator (.) angesprochen.
• Man muss eine Instanz des Structs erzeugen.
• Zur Erstellung eines C++‑Structs wird das Schlüsselwort struct verwendet.
• Zeiger auf Structs werden analog zu Zeigern auf reguläre Typen erstellt.
• Ein Struct kann wie eine gewöhnliche Variable als Argument an eine Funktion übergeben werden.