C++ · Podstawy · Struct

Struct, czyli własny typ

Gdy jedna rzecz ma kilka cech — uczeń ma imię, wiek i ocenę — nie trzymaj tego w trzech osobnych tablicach. Zrób z tego jeden typ.

Filmy z OKI

Wolisz obejrzeć?

Olimpijskie Koło Informatyczne nagrywa swoje zajęcia i udostępnia je za darmo. Poniżej 5 odcinków o tym temacie — dobre uzupełnienie, jeśli wolisz obejrzeć niż przeczytać.

Materiały Olimpijskiego Koła Informatycznego — kanał zewnętrzny. Kliknięcie odtwarza film tutaj, bez opuszczania strony.

Po co komu własny typ?

Przy parach widziałeś już ten problem: dwie osobne listy łatwo rozjechać przy sortowaniu. pair rozwiązuje to dla dwóch wartości. A co, gdy uczeń ma imię, wiek i ocenę? Trzy pola to już za dużo na parę — i tu wchodzi struct.

struct pozwala skleić kilka zmiennych w jeden nowy typ, który sam nazywasz. Każda zmienna w środku to pole, a dobierasz się do niego kropką: uczen.imie.

bez_struktury.cpp
// trzy osobne tablice - latwo o pomylke
string imiona[100];
int wiek[100];
int oceny[100];

imiona[0] = "Ala";
wiek[0] = 12;
oceny[0] = 5;

cout << imiona[0] << " " << oceny[0];
▶ Wyjście programu
Ala 5
ze_struktura.cpp
// jeden typ, trzy pola razem
struct Uczen {
    string imie;
    int wiek;
    int ocena;
};                    // <- sredniki nie zapomnij!

Uczen u;
u.imie = "Ala";
u.wiek = 12;
u.ocena = 5;

cout << u.imie << " " << u.ocena;
▶ Wyjście programu
Ala 5

Pamiętaj o średniku po zamykającej klamrze deklaracji struktury. To jedno z niewielu miejsc w C++, gdzie po klamrze stawia się średnik — i jeden z najczęstszych błędów kompilacji przy pierwszym własnym typie.

🏷️

struct Nazwa { };

Deklaracja nowego typu. Nazwę wymyślasz sam; zwyczajowo zaczyna się od dużej litery.

📦

pola w środku

Zwykłe zmienne — każda z własnym typem. Mogą być różne: string, int, double, a nawet wektor.

⚙️

Nazwa zmienna;

Po deklaracji Nazwa jest pełnoprawnym typem. Tworzysz nim zmienne jak int-em.

•

zmienna.pole

Kropka daje dostęp do pojedynczego pola. Czytasz i zapisujesz tak samo jak zwykłą zmienną.

🔨

{a, b, c}

Szybkie wypełnienie wszystkich pól naraz, w kolejności deklaracji.

❗

średnik po klamrze

}; — bez niego kompilator zgłosi dziwny błąd w następnej linijce.

podstawy.cpp
#include <iostream>
#include <string>
using namespace std;

struct Uczen {
    string imie;
    int wiek;
    double srednia;
};

int main() {
    // pole po polu
    Uczen a;
    a.imie = "Ala";
    a.wiek = 12;
    a.srednia = 4.75;

    // albo wszystko naraz, w kolejnosci pol
    Uczen b = {"Bartek", 13, 3.90};

    cout << a.imie << ", " << a.wiek
         << " lat, srednia " << a.srednia << "\n";
    cout << b.imie << ", " << b.wiek
         << " lat, srednia " << b.srednia << "\n";

    return 0;
}
▶ Wyjście programu
Ala, 12 lat, srednia 4.75 Bartek, 13 lat, srednia 3.9

Wektor struktur i sortowanie

Pojedyncza struktura przydaje się rzadko. Prawdziwa siła pojawia się, gdy wsadzisz je do wektora — dostajesz listę rzeczy, z których każda ma komplet cech i nic się nie rozjedzie.

lista.cpp
#include <iostream>
#include <vector>
#include <string>
using namespace std;

struct Uczen {
    string imie;
    int ocena;
};

int main() {
    int n;
    cin >> n;

    vector<Uczen> klasa(n);

    for (int i = 0; i < n; i++) {
        cin >> klasa[i].imie >> klasa[i].ocena;
    }

    // kto ma piatke?
    for (int i = 0; i < n; i++) {
        if (klasa[i].ocena == 5) {
            cout << klasa[i].imie << "\n";
        }
    }

    return 0;
}
▶ Wyjście programu
Wejście: 3 Ala 5 Bartek 3 Cela 5 Ala Cela

Przy sortowaniu jest jedna różnica względem par. Pary C++ umie porównywać sam, bo wie, że najpierw first, potem second. Twojej struktury nie zna — nie ma pojęcia, czy ważniejsze jest imię czy ocena. Musisz mu to powiedzieć.

po_ocenie.cpp
#include <algorithm>

vector<Uczen> klasa = {
    {"Ala", 5}, {"Bartek", 3}, {"Cela", 4}
};

// regula: kto ma stac przed kim?
sort(klasa.begin(), klasa.end(),
     [](Uczen a, Uczen b) {
         return a.ocena < b.ocena;
     });

for (Uczen u : klasa)
    cout << u.imie << " " << u.ocena << "\n";
▶ Wyjście programu
Bartek 3 Cela 4 Ala 5
po_imieniu.cpp
#include <algorithm>

vector<Uczen> klasa = {
    {"Cela", 4}, {"Ala", 5}, {"Bartek", 3}
};

// ta sama funkcja, inna regula
sort(klasa.begin(), klasa.end(),
     [](Uczen a, Uczen b) {
         return a.imie < b.imie;
     });

for (Uczen u : klasa)
    cout << u.imie << " " << u.ocena << "\n";
▶ Wyjście programu
Ala 5 Bartek 3 Cela 4

Zmieniasz jedną linijkę w środku i sortujesz po czym innym. Reguła to zawsze odpowiedź na pytanie: „czy a ma stać przed b?”. Chcesz malejąco — odwracasz znak na >.

Przekazywanie i metody

Strukturę przekazujesz do funkcji tak samo jak wszystko inne — i obowiązuje ta sama zasada co przy wektorach. Bez ampersanda funkcja dostaje kopię wszystkich pól, z ampersandem — oryginał.

przekazywanie.cpp
// tylko czyta - const &, bez kopiowania
void wypisz(const Uczen& u) {
    cout << u.imie << ": " << u.ocena << "\n";
}

// zmienia oryginal - samo &
void podnies(Uczen& u) {
    if (u.ocena < 6) u.ocena++;
}

int main() {
    Uczen a = {"Ala", 4};

    wypisz(a);
    podnies(a);
    wypisz(a);
    return 0;
}
▶ Wyjście programu
Ala: 4 Ala: 5
funkcja_zwraca.cpp
// funkcja moze tez ZWROCIC strukture
Uczen stworz(string imie, int ocena) {
    Uczen u;
    u.imie = imie;
    u.ocena = ocena;
    return u;
}

int main() {
    Uczen a = stworz("Bartek", 3);
    cout << a.imie << " " << a.ocena;
    return 0;
}
▶ Wyjście programu
Bartek 3

Struktura może mieć też własne funkcje w środku — nazywa się je metodami. Metoda widzi pola swojej struktury bez żadnych kropek i wywołuje się ją jak wszystko inne: obiekt.metoda().

metody.cpp
#include <iostream>
#include <string>
using namespace std;

struct Prostokat {
    int a, b;

    // metoda - widzi pola a i b wprost
    int pole() {
        return a * b;
    }

    int obwod() {
        return 2 * (a + b);
    }

    bool czyKwadrat() {
        return a == b;
    }
};

int main() {
    Prostokat p = {3, 4};

    cout << "Pole:   " << p.pole() << "\n";
    cout << "Obwod:  " << p.obwod() << "\n";
    cout << "Kwadrat: " << p.czyKwadrat() << "\n";

    return 0;
}
▶ Wyjście programu
Pole: 12 Obwod: 14 Kwadrat: 0

Metody nie są konieczne — wszystko da się napisać zwykłymi funkcjami. Ale gdy funkcja dotyczy wyłącznie jednej struktury, w środku czyta się ją lepiej. To zresztą pierwszy krok w stronę klas, o których usłyszysz później.

Wszystko, co robi się ze strukturą

Dziesięć zapisów, które w praktyce wyczerpują temat struktur na poziomie pierwszych zadań.

ZapisCo robiUwaga
struct Nazwa { ... }; Deklaruje nowy typ. Średnik po klamrze!
Nazwa zmienna; Tworzy obiekt tego typu. Pola mają na razie śmieci
Nazwa z = {a, b, c}; Tworzy i od razu wypełnia pola. W kolejności deklaracji
z.pole Dostęp do pojedynczego pola. Czytasz i zapisujesz jak zmienną
vector<Nazwa> v; Lista obiektów. Najczęstsze zastosowanie
v.push_back({a, b}); Dokłada nowy obiekt na koniec. Klamry zamiast konstruktora
sort(v.begin(), v.end(), regula) Sortuje po wybranym polu. Reguła obowiązkowa — C++ sam nie wie
[](Nazwa a, Nazwa b){ return a.pole < b.pole; } Reguła: rosnąco po pole. Zamień na > dla malejąco
void f(const Nazwa& z) Przekazanie bez kopiowania, tylko do odczytu. Domyślny wybór dla dużych struktur
int metoda() { ... } Funkcja w środku struktury. Widzi pola bez kropki

Wiersz ósmy to cały przepis na sortowanie po dowolnym kryterium. Podmieniasz nazwę pola i znak porównania — i masz nową kolejność. Nic więcej nie trzeba pamiętać.

Sprawdź się na zadaniach

Sześć zadań od najprostszego. Wszystkie opierają się na jednym schemacie: własny typ, wektor takich obiektów, jedno przejście albo jedno sortowanie. Najpierw spróbuj sam.

Łatwe Jeden punkt
Zdefiniuj strukturę Punkt z polami x i y. Wczytaj jeden punkt i wypisz go w formacie (3, 5).
Jak to ugryźć: Zadanie na rozgrzewkę — chodzi o samą składnię. Pamiętaj o średniku po zamykającej klamrze struktury.
Pokaż rozwiązanie
punkt.cpp
#include <iostream>
using namespace std;

struct Punkt {
    int x;
    int y;
};

int main() {
    Punkt p;
    cin >> p.x >> p.y;

    cout << "(" << p.x << ", " << p.y << ")";
    return 0;
}
Łatwe Lista uczniów
Wczytaj n uczniów (imię i ocena) i wypisz tylko tych, którzy mają ocenę wyższą niż 3.
Jak to ugryźć: Struktura z dwoma polami, wektor takich struktur i jedno przejście pętlą z if-em w środku. Żadnego sortowania.
Pokaż rozwiązanie
uczniowie.cpp
#include <iostream>
#include <vector>
#include <string>
using namespace std;

struct Uczen {
    string imie;
    int ocena;
};

int main() {
    int n;
    cin >> n;

    vector<Uczen> v(n);
    for (int i = 0; i < n; i++) {
        cin >> v[i].imie >> v[i].ocena;
    }

    for (int i = 0; i < n; i++) {
        if (v[i].ocena > 3) {
            cout << v[i].imie << " " << v[i].ocena << "\n";
        }
    }

    return 0;
}
Łatwe Najlepszy uczeń
Wczytaj n uczniów (imię i liczba punktów) i wypisz imię tego, który ma najwięcej punktów.
Jak to ugryźć: Wzorzec rekordu, który znasz z tematu Max/Min — tylko że tym razem zapamiętujesz całą strukturę, a nie samą liczbę. Zacznij od pierwszego ucznia.
Pokaż rozwiązanie
najlepszy.cpp
#include <iostream>
#include <vector>
#include <string>
using namespace std;

struct Uczen {
    string imie;
    int punkty;
};

int main() {
    int n;
    cin >> n;

    Uczen najlepszy;
    cin >> najlepszy.imie >> najlepszy.punkty;

    for (int i = 1; i < n; i++) {
        Uczen u;
        cin >> u.imie >> u.punkty;

        if (u.punkty > najlepszy.punkty) {
            najlepszy = u;          // cala strukture naraz
        }
    }

    cout << najlepszy.imie;
    return 0;
}
Średnie Sortowanie po wybranym polu
Wczytaj n książek (tytuł, autor, liczba stron). Wypisz je posortowane rosnąco po liczbie stron, a przy remisie alfabetycznie po tytule.
Jak to ugryźć: Jedna lambda z dwoma krokami: najpierw porównaj strony, a gdy są równe — porównaj tytuły. Wzorzec if (a.pole != b.pole) return ...; return ...; działa dla dowolnej liczby kryteriów.
Pokaż rozwiązanie
ksiazki.cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
using namespace std;

struct Ksiazka {
    string tytul;
    string autor;
    int strony;
};

int main() {
    int n;
    cin >> n;

    vector<Ksiazka> v(n);
    for (int i = 0; i < n; i++) {
        cin >> v[i].tytul >> v[i].autor >> v[i].strony;
    }

    sort(v.begin(), v.end(), [](Ksiazka a, Ksiazka b) {
        if (a.strony != b.strony) return a.strony < b.strony;
        return a.tytul < b.tytul;
    });

    for (Ksiazka k : v) {
        cout << k.strony << " " << k.tytul << " " << k.autor << "\n";
    }

    return 0;
}
Średnie Prostokąty z metodami
Zdefiniuj strukturę Prostokat z polami a i b oraz metodami pole() i obwod(). Wczytaj n prostokątów i wypisz ten o największym polu.
Jak to ugryźć: Metoda to zwykła funkcja napisana w środku struktury — widzi pola bez kropki. Wywołujesz ją jako p.pole(), z nawiasami.
Pokaż rozwiązanie
prostokaty.cpp
#include <iostream>
#include <vector>
using namespace std;

struct Prostokat {
    int a, b;

    int pole()  { return a * b; }
    int obwod() { return 2 * (a + b); }
};

int main() {
    int n;
    cin >> n;

    Prostokat najwiekszy;
    cin >> najwiekszy.a >> najwiekszy.b;

    for (int i = 1; i < n; i++) {
        Prostokat p;
        cin >> p.a >> p.b;

        if (p.pole() > najwiekszy.pole()) {
            najwiekszy = p;
        }
    }

    cout << najwiekszy.a << "x" << najwiekszy.b
         << " pole " << najwiekszy.pole()
         << " obwod " << najwiekszy.obwod();

    return 0;
}
Trudne Ile spotkań się zmieści
Wczytaj n spotkań, każde z godziną początku i końca. Ile najwięcej z nich da się odbyć jedno po drugim, jeśli nie mogą na siebie zachodzić?
Jak to ugryźć: Sztuczka polega na kolejności: posortuj spotkania po godzinie zakończenia, a potem bierz po kolei każde, które zaczyna się nie wcześniej niż skończyło poprzednie wybrane. Sortowanie po godzinie rozpoczęcia dałoby gorszy wynik — jedno długie spotkanie na starcie zablokowałoby resztę dnia.
Pokaż rozwiązanie
spotkania.cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

struct Spotkanie {
    int start;
    int koniec;
};

int main() {
    int n;
    cin >> n;

    vector<Spotkanie> v(n);
    for (int i = 0; i < n; i++) {
        cin >> v[i].start >> v[i].koniec;
    }

    // klucz: sortujemy po KONCU
    sort(v.begin(), v.end(), [](Spotkanie a, Spotkanie b) {
        return a.koniec < b.koniec;
    });

    int ile = 0;
    int wolnyOd = -1000000;

    for (int i = 0; i < n; i++) {
        if (v[i].start >= wolnyOd) {
            ile++;
            wolnyOd = v[i].koniec;
        }
    }

    cout << ile;
    return 0;
}

Częste błędy i dobre praktyki

❗
Średnik po klamrze
struct Nazwa { ... }; — bez tego średnika kompilator zgłosi dziwny błąd, i to zwykle w następnej linijce.
🔢
Kolejność przy klamrach
Uczen u = {"Ala", 12, 4.5}; wypełnia pola w kolejności deklaracji. Zamiana pól miejscami w strukturze cicho zepsuje wszystkie takie zapisy.
⚖️
Sortowanie wymaga reguły
C++ nie wie, po którym polu chcesz sortować. Podaj lambdę jako trzeci argument sort.
🔗
Przekazuj przez referencję
const Uczen& u nie kopiuje wszystkich pól. Przy strukturze z wektorem w środku różnica bywa ogromna.
🤔
struct czy pair?
Dwa pola o oczywistym znaczeniu — pair wystarczy. Trzy pola albo nazwy, które trzeba pamiętać — struct.
📛
Nazywaj pola po ludzku
u.ocena mówi wszystko, u.x2 nie mówi nic. To główna przewaga struktury nad parą — nie zmarnuj jej.

Gotowy na więcej?

Dołącz do T-Olimpians i trenuj z doświadczonymi mentorami. Zbuduj bazę, która prowadzi do finałów OI.