Struktury w C++ (struct): grupowanie powiązanych danych

Po co grupować dane

Do tej pory każda zmienna istniała osobno: tu int, tam string. Prawdziwe programy operują jednak na rzeczach złożonych z kilku części: punkt ma x i y, a student ma imię, wiek i średnią ocen. Przekazywanie tego wszystkiego jako luźnych, osobnych zmiennych łatwo prowadzi do błędów: nic ich ze sobą nie wiąże, a funkcja, która potrzebuje wszystkich trzech, musi przyjmować trzy parametry.

Struktura (struct) rozwiązuje ten problem. Definiuje nowy typ, który łączy powiązane zmienne, czyli jego składowe, w jedną całość. Po zdefiniowaniu traktujesz całą paczkę jak jedną wartość, którą można przechowywać, kopiować i przekazywać do funkcji.

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

struct Student {
    string name;
    int age;
    double gpa;
};   // <- nie zapomnij o średniku po klamrze zamykającej

int main() {
    Student s;          // jeden obiekt przechowujący wszystkie trzy składowe
    s.name = "Ada";
    s.age = 19;
    s.gpa = 3.9;

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

Do każdej składowej dostajesz się operatorem kropki (s.name, s.age). Średnik po zamykającym } definicji struktury jest obowiązkowy: jego pominięcie to jeden z najczęstszych błędów kompilacji u początkujących w C++.

Inicjalizacja struktury

Ręczne przypisywanie każdego pola działa, ale jest rozwlekłe i łatwo pominąć którąś składową. Czystszym rozwiązaniem jest inicjalizacja agregatowa: podajesz wartości w nawiasach klamrowych, w tej samej kolejności, w jakiej zadeklarowano składowe.

#include <iostream>
using namespace std;

struct Point {
    int x;
    int y;
};

int main() {
    Point a{3, 4};        // x = 3, y = 4 (inicjalizacja klamrowa, zalecana)
    Point origin{};       // obie składowe zainicjalizowane wartością 0
    Point b = {10, 20};   // starsza forma = {}, ten sam efekt

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

Uważaj na pustą deklarację: Point p; (bez klamer) zostawia w x i y śmieciowe wartości, bo składowe typów wbudowanych nie są automatycznie zerowane. Point p{}; inicjalizuje je wartością 0. Wybieraj klamry. Wartości domyślne możesz też wpisać od razu w definicji, dzięki czemu nawet Point p; startuje z czystym stanem:

#include <iostream>
using namespace std;

struct Config {
    int width  = 800;     // domyślne inicjalizatory składowych
    int height = 600;
    bool fullscreen = false;
};

int main() {
    Config c;             // używa wszystkich wartości domyślnych
    Config wide{1920};    // width nadpisane, reszta zachowuje wartości domyślne

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

Struktury jako parametry funkcji

Struktura to jedna wartość, więc funkcja może przyjąć jeden parametr zamiast trzech. Pamiętaj tylko, że przekazanie struktury przez wartość kopiuje wszystkie składowe. Przy czymkolwiek większym niż kilka intów przekazuj ją przez referencję const, żeby uniknąć kopii: to ta sama zasada, którą znasz ze strony o referencjach.

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

struct Student {
    string name;
    double gpa;
};

// const& unika kopiowania stringa i obiecuje, że s nie zostanie zmienione
void printStudent(const Student& s) {
    cout << s.name << ": " << s.gpa << "\n";
}

// zwracanie struktury jest w porządku: kompilator eliminuje kopię
Student makeStudent(string name, double gpa) {
    return Student{name, gpa};
}

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

Zwracanie całej struktury z funkcji to idiomatyczny sposób na oddanie kilku wartości naraz, znacznie czytelniejszy niż żonglowanie wieloma referencjami wyjściowymi.

Funkcje składowe i konstruktory

Struktura nie ogranicza się do danych. Może zawierać funkcje składowe, które operują na jej własnych składowych, oraz konstruktor, który inicjalizuje obiekt w chwili jego utworzenia. Tu struktura zaczyna przypominać mały obiekt z własnym zachowaniem.

#include <iostream>
using namespace std;

struct Rectangle {
    double width;
    double height;

    // konstruktor: uruchamia się przy tworzeniu obiektu Rectangle
    Rectangle(double w, double h) : width(w), height(h) {}

    // funkcja składowa: korzysta ze składowych własnego obiektu
    double area() const {        // const = "nie modyfikuję obiektu"
        return width * height;
    }
};

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

Wewnątrz funkcji składowej do składowych odwołujesz się po nazwie (width, height): oznaczają one kopię należącą do tego obiektu. Oznaczenie area() const mówi kompilatorowi, że funkcja tylko odczytuje obiekt, więc można ją wywołać także na wartościach const Rectangle. Konstruktory to osobny temat, łącznie ze składnią listy inicjalizacyjnej : width(w), a strona o konstruktorach omawia go dokładnie.

Struct a class: prawdziwa różnica

Często można usłyszeć, że "struktury są do danych, a klasy do obiektów". To konwencja, a nie reguła języka. W C++ struct i class to prawie to samo: jedyna wbudowana różnica to domyślny poziom dostępu.

struct S {
    int x;        // domyślnie public
};

class C {
    int x;        // domyślnie private
};

Składowe struct są public, chyba że oznaczysz je inaczej, a składowe class są od początku private. To wszystko: oba mogą mieć konstruktory, funkcje składowe, dziedziczenie i całą resztę. Do struktury możesz nawet dodać jawne specyfikatory dostępu, żeby ukryć składowe:

#include <iostream>
using namespace std;

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

private:
    int count = 0;                          // teraz ukryte
};

int main() {
    Counter c;
    c.bump();
    c.bump();
    cout << c.value() << "\n";   // 2
    // c.count = 99;   // błąd kompilacji: count jest prywatne
}

Wniosek praktyczny: używaj struct do przejrzystych paczek danych, w których każde pole można swobodnie zmieniać (Point, Color, rekord konfiguracji), a po class sięgaj wtedy, gdy chcesz ukryć stan wewnętrzny za publicznym interfejsem. Kompilator traktuje je tak samo, a słowo kluczowe jedynie sygnalizuje twoje intencje.

Tablice i wektory struktur

Struktura to zwykły typ, więc możesz umieścić wiele struktur w tablicy lub w vectorze i przechodzić po nich pętlą jak po każdej innej wartości.

#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&: bez kopii dla każdego elementu
        cout << p.name << ": $" << p.price << "\n";
        total += p.price;
    }
    cout << "Total: $" << total << "\n";
}

Zwróć uwagę na zagnieżdżone klamry: każde {"Keyboard", 49.99} inicjalizuje agregatowo jeden Product, a zewnętrzne klamry budują wektor. Użycie const Product& w pętli zakresowej sprawia, że żadna struktura nie jest kopiowana w kolejnych iteracjach. Bez & każdy element byłby niepotrzebnie kopiowany.

Dalej: typy wyliczeniowe (enum)

Struktury pozwalają zbudować typ z kilku połączonych wartości. Następny rozdział idzie w przeciwną stronę: enum definiuje typ, który przechowuje dokładnie jedną wartość z małego, nazwanego zbioru. To idealne rozwiązanie dla takich rzeczy jak Color::Red, Direction::North czy stan maszyny stanów. Zobaczysz, jak enum class daje czytelne stałe z kontrolą typów, które naturalnie współpracują ze strukturami i klasami, które teraz budujesz.