Klasa 4 · rozdział 1 · lekcje 1–9

Powtórzenie, friend i szablony

Rok zamyka algorytmy pod egzamin INF.04. Najpierw układ funkcji bez wejścia i wyjścia, potem pogłębienie friend oraz szablonów: specjalizacja, klasa liczbowa, różnica wobec polimorfizmu. Visual Studio 2026, aplikacja konsolowa.

Po tym rozdziale powinieneś umieć

  • rozdzielić algorytm (funkcja albo metoda bez cin/cout) od main;
  • napisać nagłówek funkcji w stylu arkusza: nazwa, opis, parametry, wynik;
  • zadeklarować funkcję zaprzyjaźnioną i klasę zaprzyjaźnioną oraz powiedzieć, kiedy getter wystarczy;
  • napisać szablon funkcji, specjalizację oraz szablon klasy dla typu liczbowego;
  • odróżnić wybór wersji szablonu (kompilacja) od virtual (czas działania);
  • użyć szablonu w prostym algorytmie (wieksza, zamien).

1. Rok i układ INF.04

Klasa 4 ma 2 godziny tygodniowo, 60 lekcji. I okres (lekcje 1–30, rozdziały 1–5) kończy się wyszukiwaniem. II okres dokłada sortowanie, szyfry, metody numeryczne i wzorce. Na ocenę śródroczną liczą się działy z I okresu. Ocena roczna bierze cały rok.

Na tym przedmiocie zostajesz przy C++ i konsoli. Aplikacje webowe, mobilne i desktopowe z oknami są na innych przedmiotach kwalifikacji INF.04. Tu ocenia się algorytm i obiektowość.

Układ, który wraca w zadaniach i w arkuszu: funkcja albo metoda liczy, main czyta i pisze. Funkcja nwd nie woła cin. Dostaje dwa argumenty i zwraca liczbę. Nad funkcją stoi komentarz-nagłówek.

// Nazwa: wieksza
// Opis: zwraca większy z dwóch argumentów tego samego typu
// Parametry: a, b — wartości do porównania
// Zwraca: a, gdy a > b; w przeciwnym razie b
// We/wy: brak
template <typename T>
T wieksza(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    int x, y;
    cin >> x >> y;
    cout << wieksza(x, y);
}
Nagłówek z arkusza Komentarz stoi nad funkcją, nie w środku ciała. Podajesz, co funkcja dostaje, co oddaje i czego nie robi (brak we/wy). Nazwy są znaczące: nwd, szyfruj, nie fun.

2. Powtórzenie OOP

Z klas 2–3 zostaje cztery decyzje, nie tylko słownik.

  • Pola private, usługi i gettery w public. Konstruktor na liście inicjalizacyjnej.
  • Baza trzyma wspólny wzór. Pochodna dopisuje swoje. protected widzi pochodna, nie main.
  • virtual i wskaźnik (albo referencja) do bazy: wołanie zależy od prawdziwego obiektu.
  • Pole static należy do klasy. Definicja int Klasa::ile = 0; stoi poza klasą. Metoda statyczna nie ma this.

Jeśli któreś zdanie jest puste, wróć do hermetyzacji, friend i static oraz dziedziczenia. Ten rozdział nie uczy ich od zera — używa ich w szablonach i w friend.

3. Funkcje zaprzyjaźnione

W klasie 3 friend wszedł przy operator<<, bo lewy operand to strumień, nie punkt. W klasie 4 przyjaciel to narzędzie z uzasadnieniem: funkcja spoza klasy ma zobaczyć pola prywatne dwóch obiektów naraz, a gettery rozlałyby się po całym programie.

class Wektor {
    double x, y;
public:
    Wektor(double xx, double yy) : x(xx), y(yy) {}
    friend double iloczyn(const Wektor& a, const Wektor& b);
};

double iloczyn(const Wektor& a, const Wektor& b) {
    return a.x * b.x + a.y * b.y;
}

Wektor p(1, 2), q(3, 4);
cout << iloczyn(p, q);    // 11

iloczyn nie jest metodą: nie ma this, wołasz ją jak zwykłą funkcję. Widzi x i y, bo klasa ją wpuściła. Przyjaźń nie jest dziedziczeniem i nie przechodzi dalej — przyjaciel przyjaciela nic nie widzi, dopóki sam nie dostanie friend.

Kiedy friend jest zbędny Iloczyn da się napisać na getterach: a.getX() * b.getX() + a.getY() * b.getY(). Wtedy friend nie jest potrzebny. Uzasadniasz go, gdy bez niego interfejs musiałby wystawić surowe pola albo gdy operator ma lewy operand innego typu (strumień).

4. Klasy zaprzyjaźnione

friend class B; w klasie A znaczy: każda metoda B widzi prywatne składowe A. Odwrotnie już nie — przyjaźń nie jest symetryczna, dopóki B nie odda jej w drugą stronę.

class Sejf {
    int kod;
public:
    Sejf(int k) : kod(k) {}
    friend class Serwis;
};
class Serwis {
public:
    int odczytaj(const Sejf& s) const { return s.kod; }
    void ustaw(Sejf& s, int k) const { s.kod = k; }
};

Sejf s(1234);
Serwis serwis;
serwis.ustaw(s, 9999);
cout << serwis.odczytaj(s);   // 9999
// s.kod = 1;  — błąd: main nie jest przyjacielem

main nadal nie widzi kod. Wyłom jest wąski: tylko Serwis. To ma sens, gdy jedna klasa jest narzędziem drugiej (serwis sejfu, tester algorytmu) i nie chcesz publicznego settera „dla wszystkich”.

friend a static Licznik obiektów zostaje static — należy do klasy, nie do przyjaciela. Przyjaciel może go przeczytać, jeśli jest prywatny i przyjaźń go obejmuje, ale zwykły licznik i tak wołasz przez Klasa::getIle(). Nie mieszaj tych dwóch mechanizmów w jednym zdaniu.

5. Szablony i specjalizacja

Szablon z końca klasy 3 zostawiał typ jako parametr. Kompilator generuje wersję przy wywołaniu. Specjalizacja mówi: dla jednego konkretnego typu masz osobne ciało, inne niż wzór.

template <typename T>
T polacz(T a, T b) {
    return a + b;
}

template <>
string polacz<string>(string a, string b) {
    return a + "-" + b;
}

cout << polacz(2, 3);                         // 5
cout << polacz(string("PO"), string("TIP"));   // PO-TIP

template <> i polacz<string> to pełna specjalizacja: wzór ogólny dodaje, wersja dla string wstawia myślnik. Wywołanie polacz("PO", "TIP") na gołych literałach nie wybierze tej wersji — typem literału nie jest string. Podajesz obiekty string albo piszesz polacz<string>(...).

Specjalizacja Osobna definicja szablonu dla wskazanego typu. Reszta typów idzie zwykłym wzorem. Definicja szablonu (i specjalizacji) zostaje w nagłówku, który włączasz w miejscu wywołania.

6. Szablon klasy liczbowej

Klasa na liczby ma te same operacje dla int i double: wartość, wartość bezwzględna, licznik egzemplarzy. Jeden szablon. Pole static jest osobne dla każdego typu: Opakowanie<int> i Opakowanie<double> nie dzielą licznika.

template <typename T>
class Opakowanie {
    T wartosc;
    static int ile;
public:
    Opakowanie(T w) : wartosc(w) { ile++; }
    T get() const { return wartosc; }
    T abs() const { return wartosc < 0 ? -wartosc : wartosc; }
    static int getIle() { return ile; }
};

template <typename T>
int Opakowanie<T>::ile = 0;

Opakowanie<int> a(-5), b(2);
Opakowanie<double> c(-1.5);
cout << a.abs();                         // 5
cout << Opakowanie<int>::getIle();       // 2
cout << Opakowanie<double>::getIle();    // 1

Definicja ile też jest szablonem — stoi poza klasą, raz na każdy użyty typ. abs odejmuje od zera tylko wtedy, gdy typ rozumie < i unarny minus. Dlatego ten szablon jest „dla liczb”, nie dla string.

7. Szablon a polimorfizm

Oba mechanizmy „jedno wywołanie, wiele zachowań”. Decyzja zapada w innym momencie.

Szablon Polimorfizm (virtual)
Kiedy wybór Przy kompilacji, z typu argumentu W czasie działania, z prawdziwego obiektu
Czego wymaga Typu, który umie operacje z ciała szablonu Wspólnej bazy, metody virtual, wskaźnika lub referencji
Przykład wieksza(3, 8) i wieksza(1.5, 2.5) Figura* f = new Kolo(2); f->pole();
Czego nie zastąpi Tablicy figur różnych klas w jednej pętli Funkcji max dla int, który nie dziedziczy po niczym

Szablon nie jest klasą abstrakcyjną. Polimorfizm nie wygeneruje wersji dla int, jeśli nie masz hierarchii liczb. W tym roku algorytmy na tablicach liczb idą szablonem. Hierarchie (figury, szyfry, węzły wyrażenia) zostają przy virtual.

Jedno zdanie wyboru „Typ znam przy kompilacji i nie ma wspólnej bazy” — szablon. „W pętli siedzą różne pochodne, a wołam jedną metodę” — virtual.

8. Szablon w algorytmie

Algorytm, który tylko przestawia albo porównuje, nie musi znać int. Szablon funkcji bez we/wy jest tym, co później nałożysz na sortowanie i stos.

// Nazwa: zamien
// Opis: zamienia wartości dwóch zmiennych
// Parametry: a, b — referencje do zamienianych obiektów
// Zwraca: nic
// We/wy: brak
template <typename T>
void zamien(T& a, T& b) {
    T tmp = a;
    a = b;
    b = tmp;
}

int x = 3, y = 8;
zamien(x, y);                 // x = 8, y = 3
string s = "ala", t = "ola";
zamien(s, t);                 // s = ola, t = ala

To samo ciało obsługuje liczbę i napis, bo oba da się kopiować i przypisywać. W dalszych rozdziałach zamien wchodzi do sortowania, a Stos<T> — do nawiasów i do ONP.

Ćwiczenia do samodzielnego wykonania

Folder: Dokumenty\cwiczenia-po\klasa-4\rozdzial-01.

Ćwiczenie 1. Nagłówek łatwe

Nad wieksza dopisz komentarz: nazwa, opis, parametry, zwrot, brak we/wy. main czyta dwie liczby i wypisuje wynik.

Ćwiczenie 2. Iloczyn łatwe

Klasa z dwoma polami prywatnymi i friend funkcja licząca iloczyn. Wynik dla (1, 2) i (3, 4): 11. W komentarzu: czemu nie metoda.

Ćwiczenie 3. Klasa zaprzyjaźniona średnie

friend class czyta i zmienia prywatne pole. main nie kompiluje się przy bezpośrednim dostępie — zostaw tę linię w komentarzu z komunikatem kompilatora.

Ćwiczenie 4. Specjalizacja średnie

polacz dla liczb dodaje, dla string wstawia myślnik. Pokaż oba wywołania.

Ćwiczenie 5. Opakowanie średnie

Szablon Opakowanie<T> z abs i licznikiem static. Dwa int i jeden double. Liczniki: 2 i 1.

Ćwiczenie 6. Wybór mechanizmu trudne

Masz tablicę kół i prostokątów oraz osobno funkcję „większa z dwóch liczb”. Napisz, które zadanie bierze virtual, a które szablon, i zaimplementuj oba w jednym projekcie.

Sprawdź się

1. W układzie z tego rozdziału funkcja algorytmu:
2. friend class Serwis w klasie Sejf oznacza:
3. Specjalizacja szablonu:
4. Opakowanie<int>::getIle i Opakowanie<double>::getIle:
5. Szablon a polimorfizm:

Wymagania na ocenę

Dział 1 planu (lekcje 1–9). Ocena wyższa zawiera wymagania na oceny niższe.

OcenaUczeń
2 Zna tematykę klasy 4. Przypomina: klasa, dziedziczenie, szablon, wyjątek. Uruchamia szablon funkcji według wzoru.
3 Definiuje funkcję zaprzyjaźnioną i szablon funkcji. Definiuje szablon klasy liczbowej według przykładu. Opisuje układ: funkcja bez we/wy, main z we/wy.
4 Stosuje klasę zaprzyjaźnioną i składnik static. Specjalizuje szablon albo ogranicza go do liczb. Porównuje szablon z polimorfizmem na przykładzie.
5 Wkłada szablon w prosty algorytm (zamien, wieksza). Uzasadnia, kiedy friend jest potrzebny, a kiedy wystarczy getter. Pisze nagłówek funkcji.
6 Projektuje szablon do ponownego użycia w algorytmach z dalszej części roku. Łączy szablon z hierarchią albo świadomie z niego rezygnuje.

Lista „już umiem”