Klasa 3 · rozdział 7

Zaprzyjaźnienie i szablony

Najpierw krótko utrwalasz friend. Potem poznajesz szablony: piszesz funkcję albo klasę raz, a kompilator sam robi z niej wersję dla int, double czy string. Tak zbudowany jest vector, którego używasz od roku. Visual Studio 2026.

Po tym rozdziale powinieneś umieć

  • napisać funkcję zaprzyjaźnioną i klasę zaprzyjaźnioną oraz uzasadnić, kiedy warto;
  • zdefiniować szablon funkcji (np. wiekszy, zamien) i wywołać go dla kilku typów;
  • wskazać, kiedy szablon zastępuje kilka przeciążonych funkcji, i jakie ma ograniczenia;
  • zdefiniować szablon klasy z metodami w klasie i poza nią;
  • napisać szablon klasy dla prostych typów liczbowych (INF.04.4.8);
  • porównać szablon z polimorfizmem (kompilacja kontra czas wykonania).

1. Funkcje i klasy zaprzyjaźnione — utrwalenie

Przypomnienie z rozdziału 3: funkcja zaprzyjaźniona nie jest metodą klasy, ale ma dostęp do jej składowych private. Najczęściej spotkasz ją przy operator<< — teraz, po rozdziale 6, wiesz, że działa on i dla ekranu, i dla pliku.

class Punkt {
private:
    int x, y;
public:
    Punkt(int x, int y) : x(x), y(y) {}
    friend ostream &operator<<(ostream &out, const Punkt &p);
};

ostream &operator<<(ostream &out, const Punkt &p) {
    out << "(" << p.x << ", " << p.y << ")";   // widzi private x, y
    return out;
}

Klasa zaprzyjaźniona

Cała klasa może być przyjacielem. Wtedy wszystkie jej metody widzą prywatne pola drugiej klasy. Przykład: kasa w banku zmienia saldo konta bezpośrednio, a zwykły program — tylko przez wpłatę.

class Konto {
private:
    string numer;
    double saldo;
public:
    Konto(string n) : numer(n), saldo(0) {}
    double getSaldo() const { return saldo; }
    friend class Kasa;          // Kasa ma dostęp do private
};

class Kasa {
public:
    void przelew(Konto &z, Konto &na, double kwota) {
        if (kwota > 0 && z.saldo >= kwota) {
            z.saldo -= kwota;
            na.saldo += kwota;
        }
    }
};
Przyjaźń nie jest dziedziczeniem Przyjaźń daje się w jedną stronę (Kasa widzi Konto, ale nie odwrotnie), nie przechodzi na klasy pochodne i łamie hermetyzację. Używaj jej oszczędnie — jeśli wystarczy publiczna metoda, wybierz metodę.

2. Szablon funkcji

Potrzebujesz funkcji zwracającej większą z dwóch wartości. Przeciążaniem wyszłoby tak:

int    wiekszy(int a, int b)       { return a > b ? a : b; }
double wiekszy(double a, double b) { return a > b ? a : b; }
string wiekszy(string a, string b) { return a > b ? a : b; }

Trzy razy ten sam kod, różni się tylko typ. Szablon funkcji (wzorzec) pozwala zapisać to raz, a typ zamienić na parametr T:

template <typename T>
T wiekszy(T a, T b) {
    return a > b ? a : b;
}

int main() {
    cout << wiekszy(3, 8) << endl;                         // T = int    → 8
    cout << wiekszy(2.5, 1.5) << endl;                     // T = double → 2.5
    cout << wiekszy(string("kot"), string("pies")) << endl; // T = string → pies
    cout << wiekszy<double>(3, 2.5) << endl;              // typ podany jawnie → 3
}
Jak to działa template <typename T> mówi: „T to jakiś typ, poznasz go przy wywołaniu”. Kompilator patrzy na argumenty, ustala T i w czasie kompilacji generuje zwykłą funkcję dla tego typu. Zamiast typename możesz spotkać class — znaczy to samo.
wiekszy(3, 2.5) się nie skompiluje Pierwszy argument sugeruje int, drugi double — kompilator nie wie, które T wybrać. Podaj typ jawnie: wiekszy<double>(3, 2.5).

Szablon zamiany wartości — przyda się w każdym sortowaniu:

template <typename T>
void zamien(T &a, T &b) {
    T pom = a;
    a = b;
    b = pom;
}

3. Szablon w praktyce i jego ograniczenia

Szablon świetnie łączy się z vector — jedna funkcja dla wektora liczb całkowitych i rzeczywistych:

template <typename T>
T suma(const vector<T> &v) {
    T s = T();             // "zero" dla typu T: 0 dla int, 0.0 dla double
    for (T e : v) {
        s += e;
    }
    return s;
}

template <typename T>
void sortuj(vector<T> &v) {
    int n = (int)v.size();
    for (int i = 0; i < n - 1; i++)
        for (int j = 0; j < n - 1 - i; j++)
            if (v[j + 1] < v[j])
                zamien(v[j], v[j + 1]);
}

sortuj zadziała dla vector<int>, vector<double> i vector<string> (alfabetycznie). Ale dla vector<Punkt> — nie.

Ograniczenie szablonu Szablon zakłada, że typ T obsługuje operacje użyte w środku. sortuj używa <, więc Punkt musiałby mieć przeciążony operator<. Bez tego kompilator zgłosi błąd — często długi i mało czytelny. Czytaj go od pierwszej linii: tam jest nazwa brakującej operacji.
Szablon czy przeciążenie? Szablon — gdy kod jest identyczny dla wszystkich typów (max, zamiana, suma, sortowanie). Przeciążenie — gdy dla różnych typów kod jest inny (np. pole(Kolo) i pole(Prostokat)).

4. Szablon klasy

Tak jak funkcję, możesz sparametryzować całą klasę. vector<int> to właśnie szablon klasy vector z parametrem int. Napiszmy własny: pudełko na jedną wartość dowolnego typu.

template <typename T>
class Pudelko {
private:
    T zawartosc;
public:
    Pudelko(T z) : zawartosc(z) {}
    T get() const { return zawartosc; }
    void set(T z);                 // definicja poza klasą — niżej
};

template <typename T>
void Pudelko<T>::set(T z) {      // znów template i Pudelko<T>::
    zawartosc = z;
}

int main() {
    Pudelko<int> a(5);
    Pudelko<string> b("tajemnica");
    a.set(10);
    cout << a.get() << " " << b.get() << endl;   // 10 tajemnica
}

Przy szablonie klasy typ podajesz w nawiasach ostrych przy tworzeniu obiektu: Pudelko<int>. Pudelko<int> i Pudelko<string> to dwa różne typy.

Szablon w pliku nagłówkowym W rozdziale 5 dzieliłeś klasę na .h i .cpp. Szablonu tak nie dzielisz: cała definicja (także ciała metod) zostaje w pliku .h, np. Pudelko.h. Kompilator musi widzieć cały wzór w miejscu użycia, żeby wygenerować wersję dla konkretnego typu. W main.cpp wystarczy #include "Pudelko.h".

Szablon z dwoma parametrami

template <typename K, typename W>
class Para {
public:
    K klucz;
    W wartosc;
    Para(K k, W w) : klucz(k), wartosc(w) {}
};

Para<string, int> p("wiek", 17);

5. Szablon klasy dla prostych typów liczbowych

Podstawa programowa (INF.04.4.8) mówi wprost o szablonach klas obsługujących proste typy liczbowe. Typowy przykład: klasa zbierająca pomiary i licząca statystyki — raz dla int (punkty), raz dla double (temperatury).

template <typename T>
class Statystyka {
private:
    vector<T> dane;
public:
    void dodaj(T x) { dane.push_back(x); }
    int ile() const { return (int)dane.size(); }

    T suma() const {
        T s = T();
        for (T e : dane) s += e;
        return s;
    }

    double srednia() const {          // zawsze double — średnia z int bywa ułamkiem
        if (dane.empty()) return 0;
        return (double)suma() / dane.size();
    }

    T maks() const {                 // zakładamy, że dane nie są puste
        T m = dane[0];
        for (T e : dane)
            if (e > m) m = e;
        return m;
    }
};

int main() {
    Statystyka<int> punkty;
    punkty.dodaj(7);
    punkty.dodaj(10);
    punkty.dodaj(8);
    cout << punkty.suma() << " " << punkty.srednia() << endl;   // 25 8.33333

    Statystyka<double> temp;
    temp.dodaj(21.5);
    temp.dodaj(-3.0);
    cout << temp.maks() << endl;                                  // 21.5
}
Spróbuj złamać szablon Utwórz Statystyka<string> i wywołaj srednia(). Przeczytaj błąd kompilacji: nie da się zamienić string na double. To dowód, że szablon jest sprawdzany dla konkretnego typu dopiero przy użyciu.

6. Szablon a polimorfizm

Oba mechanizmy pozwalają pisać jeden kod dla „wielu rzeczy”, ale działają w innym momencie.

Szablon

Kompilator generuje osobną wersję dla każdego typu — decyzja zapada w czasie kompilacji. Typy nie muszą mieć wspólnej bazy, wystarczy, że obsługują użyte operacje (int i double nie mają wspólnej klasy bazowej).

Polimorfizm (virtual)

Jedna metoda w bazie, różne wersje w klasach pochodnych. Właściwa wersja wybierana jest w czasie działania programu (wiązanie dynamiczne). Wymaga hierarchii klas. W jednym vector<Figura*> trzymasz koła i prostokąty naraz.

Mechanizmy można łączyć: szablon funkcji sumującej pola figur trzymanych w wektorze wskaźników.

template <typename T>
double sumaPol(const vector<T*> &figury) {
    double s = 0;
    for (T *f : figury) {
        s += f->pole();     // pole() jest virtual — polimorfizm
    }
    return s;
}
// wywołanie: sumaPol(figury) dla vector<Figura*> — szablon ustala T = Figura
Co dalej? W klasie 4 wrócisz do szablonów: specjalizacja szablonu, stos jako szablon klasy i szablony w algorytmach egzaminacyjnych (klasa 4, rozdział 1).

Ćwiczenia do samodzielnego wykonania

Folder: Dokumenty\cwiczenia-po\klasa-3\rozdzial-07.

Ćwiczenie 1. Ułamek na ekranie łatwe

Klasa Ulamek (licznik, mianownik — private) z zaprzyjaźnionym operator<< wypisującym 3/4. Wypisz ułamek na ekran i do pliku.

Ćwiczenie 2. Mniejszy z dwóch łatwe

Szablon mniejszy(T a, T b). Wywołaj dla int, double, char i string. Potem wywołaj mniejszy(4, 2.5), przeczytaj błąd i popraw jawnym typem.

Ćwiczenie 3. Klasa zaprzyjaźniona średnie

Klasy Magazyn (prywatna liczba sztuk) i Inwentaryzacja (friend), która może ustawić stan po liczeniu. Zwykły kod zmienia stan tylko przez przyjmij i wydaj. W komentarzu: czy friend był tu konieczny?

Ćwiczenie 4. Szablony na wektorach średnie

Szablony suma, maks i ileWiekszych(v, prog) dla vector<T>. Bez we/wy w funkcjach. Przetestuj dla int i double.

Ćwiczenie 5. Para średnie

Szablon klasy Para<T> z dwoma polami tego samego typu i metodami pierwszy(), drugi(), zamien(), wiekszy(). Definicje metod poza klasą, całość w Para.h.

Ćwiczenie 6. Statystyka z pliku średnie

Użyj Statystyka<double> z podrozdziału 5 i dodaj metodę mini(). Wczytaj temperatury z pliku (rozdział 6) i wypisz sumę, średnią, minimum i maksimum z dwoma miejscami po przecinku.

Ćwiczenie 7. Sortowanie dla wszystkich trudne

Szablon sortuj(vector<T>&). Posortuj liczby, napisy, a potem obiekty Uczen według średniej — dopisz w klasie operator<. W komentarzu: dlaczego bez operatora się nie kompilowało?

Metoda w klasie: bool operator<(const Uczen &inny) const { return srednia() < inny.srednia(); }

Ćwiczenie 8. Prosty stos jako szablon trudne

Szablon klasy Stos<T> na vector: poloz, zdejmij, szczyt, pusty. Przetestuj dla int i string. Opisz w komentarzu, czym ten stos różni się od hierarchii z virtual.

Sprawdź się

1. Klasa zaprzyjaźniona:
2. Główna idea szablonu to:
3. Wywołanie wiekszy(3, 2.5) szablonu T wiekszy(T a, T b):
4. Gdzie umieszczasz definicje metod szablonu klasy?
5. Szablon a funkcje wirtualne:

Wymagania na ocenę

Ocena wyższa zawiera wymagania na oceny niższe. Dział 8: szablony funkcji i klas (lekcje 44–51).

Ocena Uczeń
2 Wyjaśnia ideę szablonu: jeden zapis dla wielu typów. Rozpoznaje template w gotowym kodzie. Przypomina pojęcie funkcji zaprzyjaźnionej.
3 Definiuje szablon funkcji (maksimum, zamiana) i wywołuje go dla int i double. Według wzoru definiuje szablon prostej klasy. Stosuje klasę zaprzyjaźnioną w zadaniu z lekcji.
4 Definiuje szablony klas dla prostych typów liczbowych (INF.04.4.8). Oddziela deklarację szablonu (nagłówek) od użycia. Podaje przykład, kiedy szablon zastępuje przeciążenie.
5 Porównuje szablony z polimorfizmem (kompilacja kontra czas wykonania). Implementuje szablon klasy (para, stos, opakowanie liczby) i testuje go dla kilku typów. Uzasadnia ograniczenia szablonu.
6 Projektuje szablon dopasowany do zagadnienia i łączy go z hierarchią klas albo uzasadnia, że szablon wystarcza. Świadomie porównuje własny szablon z std::vector.

Lista „już umiem”