C++-Structs: Zusammengehörige Daten zu einem Typ bündeln

Warum Daten zusammenfassen

Bisher stand jede Variable für sich allein: hier ein int, dort ein string. Doch echte Programme haben es mit Dingen zu tun, die aus mehreren Teilen bestehen – ein Punkt hat ein x und ein y, ein Student hat einen Namen, ein Alter und einen Notendurchschnitt. Solche Werte als lose, getrennte Variablen herumzureichen ist fehleranfällig; nichts verbindet sie, und eine Funktion, die alle drei braucht, muss alle drei Parameter entgegennehmen.

Ein Struct löst das. Er definiert einen neuen Typ, der zusammengehörige Variablen – seine Member – zu einer Einheit bündelt. Einmal definiert, behandelst du das gesamte Bündel als einen einzigen Wert, den du speichern, kopieren und an Funktionen übergeben kannst.

#include <iostream>
#include <string>
using namespace std;

struct Student {
    string name;
    int age;
    double gpa;
};   // <- das Semikolon nach der schließenden Klammer nicht vergessen

int main() {
    Student s;          // ein Objekt, das alle drei Member enthält
    s.name = "Ada";
    s.age = 19;
    s.gpa = 3.9;

    cout << s.name << " is " << s.age << " (GPA " << s.gpa << ")\n";
}

Auf jeden Member greifst du mit dem Punktoperator zu (s.name, s.age). Das Semikolon nach der schließenden } einer Struct-Definition ist Pflicht – es wegzulassen ist einer der häufigsten Kompilierfehler von C++-Anfängern.

Einen Struct initialisieren

Jedes Feld von Hand zuzuweisen funktioniert, ist aber umständlich, und man vergisst leicht einen Member. Die sauberere Variante ist die Aggregat-Initialisierung: Liste die Werte in geschweiften Klammern auf, in derselben Reihenfolge, in der die Member deklariert wurden.

#include <iostream>
using namespace std;

struct Point {
    int x;
    int y;
};

int main() {
    Point a{3, 4};        // x = 3, y = 4 (Klammer-Init, bevorzugt)
    Point origin{};       // beide Member wertinitialisiert auf 0
    Point b = {10, 20};   // ältere = {}-Form, identische Wirkung

    cout << a.x << "," << a.y << "\n";          // 3,4
    cout << origin.x << "," << origin.y << "\n"; // 0,0
    cout << b.x << "," << b.y << "\n";           // 10,20
}

Vorsicht beim leeren Standardfall: Point p; (ohne Klammern) lässt x und y mit Müllwerten zurück, weil Member eingebauter Typen nicht automatisch genullt werden. Point p{}; wertinitialisiert sie auf 0. Bevorzuge die Klammern. Du kannst Standardwerte auch direkt in die Definition einbauen, sodass selbst Point p; sauber startet:

#include <iostream>
using namespace std;

struct Config {
    int width  = 800;     // Standard-Member-Initialisierer
    int height = 600;
    bool fullscreen = false;
};

int main() {
    Config c;             // verwendet alle Standardwerte
    Config wide{1920};    // width überschrieben, der Rest behält die Standards

    cout << c.width << "x" << c.height << "\n";        // 800x600
    cout << wide.width << "x" << wide.height << "\n";  // 1920x600
}

Structs als Funktionsparameter

Ein Struct ist ein einziger Wert, daher kann eine Funktion einen Parameter statt drei entgegennehmen. Denk nur daran, dass das Übergeben eines Structs per Wert alle Member kopiert. Für alles, was größer als ein paar ints ist, übergib per const-Referenz, um die Kopie zu sparen – dieselbe Regel, die du auf der Seite zu Referenzen gesehen hast.

#include <iostream>
#include <string>
using namespace std;

struct Student {
    string name;
    double gpa;
};

// const& vermeidet das Kopieren des Strings und verspricht, s nicht zu ändern
void printStudent(const Student& s) {
    cout << s.name << ": " << s.gpa << "\n";
}

// einen Struct zurückzugeben ist in Ordnung - der Compiler optimiert die Kopie weg
Student makeStudent(string name, double gpa) {
    return Student{name, gpa};
}

int main() {
    Student top = makeStudent("Grace", 4.0);
    printStudent(top);
}

Einen ganzen Struct aus einer Funktion zurückzugeben ist die idiomatische Art, mehrere Werte auf einmal zurückzuliefern – weit sauberer, als mit mehreren Ausgabe-Referenzen zu jonglieren.

Member-Funktionen und Konstruktoren hinzufügen

Ein Struct beschränkt sich nicht auf Daten. Er kann Member-Funktionen enthalten, die auf seinen eigenen Membern arbeiten, und einen Konstruktor, der das Objekt im Moment seiner Erzeugung initialisiert. Hier beginnt ein Struct, wie ein kleines Objekt mit Verhalten auszusehen.

#include <iostream>
using namespace std;

struct Rectangle {
    double width;
    double height;

    // Konstruktor: läuft, wenn ein Rectangle erstellt wird
    Rectangle(double w, double h) : width(w), height(h) {}

    // Member-Funktion: nutzt die eigenen Member des Objekts
    double area() const {        // const = "ich ändere das Objekt nicht"
        return width * height;
    }
};

int main() {
    Rectangle r(4.0, 5.0);
    cout << "area = " << r.area() << "\n";   // area = 20
}

Innerhalb einer Member-Funktion wird auf die Member über ihren Namen zugegriffen (width, height) – sie beziehen sich auf die Kopie dieses Objekts. area() const zu markieren teilt dem Compiler mit, dass die Funktion das Objekt nur liest, wodurch du sie auch auf const Rectangle-Werten aufrufen kannst. Konstruktoren sind ein Thema für sich, einschließlich der Initialisiererlisten-Syntax : width(w) – die Seite zu Konstruktoren geht in die Tiefe.

Struct vs. class: der wahre Unterschied

Du hast vielleicht gehört, dass „Structs für Daten und Klassen für Objekte da sind". Das ist eine Konvention, keine Sprachregel. In C++ sind ein struct und eine class fast dasselbe – der einzige eingebaute Unterschied ist die Standard-Zugriffsebene.

struct S {
    int x;        // standardmäßig public
};

class C {
    int x;        // standardmäßig private
};

Member eines struct sind public, sofern du sie nicht anders markierst; die einer class starten als private. Das war's – beide können Konstruktoren, Member-Funktionen, Vererbung und alles andere haben. Du kannst einem Struct sogar explizite Zugriffsspezifizierer hinzufügen, um Member zu verbergen:

#include <iostream>
using namespace std;

struct Counter {
    int value() const { return count; }   // public
    void bump() { count++; }

private:
    int count = 0;                          // jetzt verborgen
};

int main() {
    Counter c;
    c.bump();
    c.bump();
    cout << c.value() << "\n";   // 2
    // c.count = 99;   // Kompilierfehler - count ist private
}

Die praktische Erkenntnis: Verwende struct für transparente Datenbündel, bei denen jedes Feld frei angefasst werden soll (ein Point, eine Color, ein Konfigurationsdatensatz), und greife zu class, wenn du den internen Zustand hinter einer öffentlichen Schnittstelle schützen willst. Der Compiler behandelt sie gleich; das Schlüsselwort signalisiert nur deine Absicht.

Arrays und Vectors von Structs

Da ein Struct ein gewöhnlicher Typ ist, kannst du viele davon in ein Array oder einen Vector packen und wie über jeden anderen Wert darüber iterieren.

#include <iostream>
#include <vector>
#include <string>
using namespace std;

struct Product {
    string name;
    double price;
};

int main() {
    vector<Product> cart = {
        {"Keyboard", 49.99},
        {"Mouse", 19.99},
        {"Monitor", 199.00},
    };

    double total = 0;
    for (const Product& p : cart) {   // const& - keine Kopie pro Element
        cout << p.name << ": $" << p.price << "\n";
        total += p.price;
    }
    cout << "Total: $" << total << "\n";
}

Beachte die verschachtelten Klammern: Jedes {"Keyboard", 49.99} aggregat-initialisiert ein Product, und die äußeren Klammern bauen den Vector. const Product& in der bereichsbasierten Schleife zu verwenden vermeidet das Kopieren jedes Structs in jeder Iteration – lässt du das & weg, würdest du jedes Element unnötig duplizieren.

Als Nächstes: Enums

Mit Structs baust du einen Typ aus mehreren zusammengefassten Werten. Das nächste Kapitel geht in die umgekehrte Richtung: Ein Enum definiert einen Typ, der genau einen Wert aus einer kleinen, benannten Menge halten kann – perfekt für Dinge wie Color::Red, Direction::North oder den Zustand eines Zustandsautomaten. Du wirst sehen, wie enum class dir lesbare, typsichere Konstanten gibt, die sich natürlich mit den Structs und Klassen kombinieren lassen, die du jetzt baust.