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;
}
}
};
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
}
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.
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.
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.
.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
}
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
Ć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?
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ę
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. |