Klasa 3 · rozdział 3
Konstruktory, przeciążanie i static
Klasa przestaje być „workiem pól”. Staje się typem: jak powstaje instancja, jak się kopiuje, jak dodajesz dwa obiekty. Hermetyzacja z rozdziału 2 zostaje.
Po tym rozdziale powinieneś umieć
- zdefiniować konstruktor z parametrami i listą inicjalizacyjną;
- powiedzieć, po co destruktor, i kiedy potrzebny konstruktor kopiujący;
- przeciążyć funkcję i wybrany operator;
- napisać funkcję zaprzyjaźnioną i odróżnić ją od dziedziczenia;
- użyć pola i metody
static; - przepisać krótki program strukturalny na klasę.
1. Konstruktory i lista inicjalizacyjna
Konstruktor to metoda wołana automatycznie przy tworzeniu instancji.
Nie piszesz a.Punkt() — wystarczy Punkt a; albo Punkt b(3, 4);.
Nazwa konstruktora = nazwa klasy, nie ma typu zwracanego (nawet void).
Może być kilka konstruktorów — różne listy parametrów (przeciążenie).
Kompilator wybiera ten, który pasuje do wywołania, tak jak przy dwóch funkcjach max2.
class Punkt {
double x, y;
public:
Punkt() : x(0), y(0) {} // domyślny
Punkt(double xx, double yy) : x(xx), y(yy) {} // z parametrami
double getX() const { return x; }
double getY() const { return y; }
};
int main() {
Punkt a; // (0, 0)
Punkt b(3, 4); // (3, 4)
cout << a.getX() << " " << b.getY(); // 0 4
}
Dwukropek po nagłówku to lista inicjalizacyjna: atrybuty dostają wartości
zanim wejdzie ciało konstruktora. Dla double dałoby się też
x = xx; w klamrach — wynik ten sam. Lista jest obowiązkowa przy
const i referencjach (ich nie da się „dopisać” później) i przy wywołaniu
konstruktora klasy bazowej (następny rozdział).
Drugi przykład z życia: konto nie może powstać z ujemnym saldem. Konstruktor to pierwsze miejsce, w którym klasa broni swoich zasad.
class Konto {
double saldo;
public:
Konto(double s) : saldo(s > 0 ? s : 0) {}
double getSaldo() const { return saldo; }
};
Konto k(-50);
// k.getSaldo() == 0 — nie -50
Punkt a; woła konstruktor domyślny. Punkt a(); to nie obiekt —
kompilator czyta to jako deklarację funkcji. Nawiasów przy zerze argumentów nie stawiaj.
2. Destruktor i konstruktor kopiujący
Destruktor ~Klasa() woła się, gdy instancja ginie:
koniec bloku { }, koniec main, albo delete na obiekcie z new.
Nie przekazujesz mu argumentów. Przy polach int / double / string
wystarcza wersja, którą dopisze kompilator — te typy sprzątają się same.
Własny destruktor jest potrzebny, gdy klasa trzyma zasób: tablicę z new,
otwarty plik, uchwyt. Bez delete[] pamięć wycieka przy każdym zniszczonym obiekcie.
Konstruktor kopiujący Klasa(const Klasa&) powstaje nowa instancja
z innej: Bufor b2 = b1; albo przekazanie obiektu do funkcji przez wartość.
Domyślny kopiuje każde pole „jak leży”. Dla wskaźnika to kopia adresu, nie tablicy —
obie instancje wskazują ten sam kawałek pamięci (płytka kopia).
Potem jeden destruktor zwalnia tablicę, drugi zwalnia ją drugi raz — program się wywraca.
Albo zmiana w kopii psuje oryginał.
class Bufor {
int n;
int* p;
public:
Bufor(int nn) : n(nn), p(new int[nn]) {
for (int i = 0; i < n; i++) p[i] = 0;
}
Bufor(const Bufor& inny) : n(inny.n), p(new int[inny.n]) {
for (int i = 0; i < n; i++) p[i] = inny.p[i];
}
~Bufor() { delete[] p; }
void set(int i, int v) { p[i] = v; }
int get(int i) const { return p[i]; }
};
int main() {
Bufor a(3);
a.set(0, 7);
Bufor b = a; // głęboka kopia — własna tablica
b.set(0, 9);
cout << a.get(0); // 7, nie 9
}
a dostaje tablicę trzech zer, potem komórka 0 = 7.
b = a alokuje drugą tablicę i kopiuje 7, 0, 0.
b.set(0, 9) rusza tylko tablicę b.
Na końcu main najpierw ginie b, potem a — dwa osobne delete[].
b = a po utworzeniu,
dopóki nie przerobicie przypisania). Przy samych liczbach w klasie — nic z tej trójki nie dopisuj.
3. Przeciążanie funkcji i operatorów
Przeciążenie (overload): ta sama nazwa, różne parametry (liczba albo typy). Kompilator patrzy na wywołanie i wybiera pasującą wersję przy kompilacji. To nie jest funkcja wirtualna — tam wybór następuje w czasie działania i wymaga dziedziczenia (rozdział 4).
int max2(int a, int b) {
return a > b ? a : b;
}
double max2(double a, double b) {
return a > b ? a : b;
}
int main() {
cout << max2(3, 8) << endl; // wersja int → 8
cout << max2(2.5, 2.1) << endl; // wersja double → 2.5
}
Nie wystarczy różny typ zwracany przy tych samych parametrach — kompilator nie wie, którą wersję wziąć. Różnić się muszą argumenty.
Operator to też funkcja, tylko wołana zapisem a + b zamiast dodaj(a, b).
Jako metoda klasy: lewy operand to this, prawy to parametr.
class Punkt {
double x, y;
public:
Punkt(double xx = 0, double yy = 0) : x(xx), y(yy) {}
Punkt operator+(const Punkt& p) const {
return Punkt(x + p.x, y + p.y);
}
bool operator==(const Punkt& p) const {
return x == p.x && y == p.y;
}
double getX() const { return x; }
double getY() const { return y; }
};
Punkt a(1, 2), b(3, 4);
Punkt c = a + b; // (4, 6)
if (c == Punkt(4, 6)) cout << "OK";
a + b nie zmienia a ani b — zwraca nowy punkt
(stąd const na metodzie). Na sali najczęściej: +, ==
oraz << do strumienia (ten zwykle jako friend, bo lewy operand to cout, nie Punkt).
+ dla punktów = suma współrzędnych, każdy to zrozumie.
+ dla konta, które „dodaje klienta” — już nie. Wtedy zwykła metoda z nazwą.
4. friend
Deklaracja friend w klasie mówi: ta funkcja (albo cała inna klasa)
widzi składowe private i protected.
To nie jest metoda — nie ma this, wołasz ją jak zwykłą funkcję.
To też nie jest dziedziczenie — pochodna nie dostaje prywatnych pól bazy,
a friend nie tworzy hierarchii.
Klasyczny powód na sali: cout << p. Lewy operand to strumień, nie punkt,
więc operator nie może być metodą Punkt. Albo dajesz publiczne gettery
i piszesz operator obok klasy, albo wpuszczasz operator do środka przez friend.
class Punkt {
double x, y;
public:
Punkt(double xx = 0, double yy = 0) : x(xx), y(yy) {}
friend ostream& operator<<(ostream& os, const Punkt& p);
};
ostream& operator<<(ostream& os, const Punkt& p) {
os << "(" << p.x << ", " << p.y << ")";
return os;
}
int main() {
Punkt a(3, 4);
cout << a; // (3, 4)
}
Funkcja czyta p.x wprost, bo jest przyjacielem. Zwraca os,
żeby dało się łańcuchować: cout << a << endl.
5. Składniki statyczne
Zwykłe pole należy do konkretnej instancji: każde konto ma własne saldo.
Pole static należy do klasy — wszystkie obiekty widzą tę samą szufladkę.
Typowe zastosowania: licznik utworzonych instancji, wspólny kurs VAT, jeden limit.
Metoda statyczna nie dostaje this (nie ma „tego obiektu”).
Wołasz ją przez klasę: Konto::getIle(). Może czytać tylko pola statyczne,
nie saldo konkretnego konta.
class Konto {
double saldo;
static int ile;
public:
Konto(double s) : saldo(s) { ile++; }
double getSaldo() const { return saldo; }
static int getIle() { return ile; }
};
int Konto::ile = 0; // definicja poza klasą — obowiązkowa
int main() {
cout << Konto::getIle() << endl; // 0
Konto a(100), b(50), c(0);
cout << Konto::getIle(); // 3
}
Deklaracja w klasie tylko zapowiada pole. Pamięć i wartość początkowa powstają
w definicji int Konto::ile = 0; w pliku .cpp (albo pod klasą w jednym pliku).
Bez niej linker zgłosi „nierozwiązany symbol”.
main ile jest 0. Każdy konstruktor robi ile++.
Trzy obiekty → 3. Nie ma trzech osobnych liczników — jeden, wspólny.
a.getSaldo() to 100, b.getSaldo() to 50: salda są zwykłymi polami.
static int k w funkcji to zmienna, która przeżywa kolejne wywołania.
static w klasie to wspólny składnik instancji. To dwa różne znaczenia słowa.
6. Klasa jako typ — refaktoryzacja
Program strukturalny z klasy 2 trzyma dane w luźnych zmiennych.
Gdy pojawia się drugi prostokąt, dopisujesz a2, b2, pole2 — i zaraz trzeci.
Klasa zbiera to, co należy do jednego bytu: boki, konstruktor, wzory.
Było (dwa zestawy zmiennych, liczenie w main):
double a1 = 3, b1 = 4, a2 = 5, b2 = 2;
cout << a1 * b1 << " " << 2 * (a1 + b1) << endl;
cout << a2 * b2 << " " << 2 * (a2 + b2);
Ma być (ten sam wynik: 12 14 oraz 10 14):
class Prostokat {
double a, b;
public:
Prostokat(double aa, double bb) : a(aa), b(bb) {}
double pole() const { return a * b; }
double obwod() const { return 2 * (a + b); }
};
int main() {
Prostokat p(3, 4), q(5, 2);
cout << p.pole() << " " << p.obwod() << endl;
cout << q.pole() << " " << q.obwod();
}
Kryterium sukcesu: dla tych samych danych te same liczby na ekranie.
We/wy zostaje w main. Kolejny prostokąt to kolejna instancja, nie kolejna para zmiennych.
- Wypisz atrybuty i metody na kartce (wzór klasy).
- Konstruktor + lista inicjalizacyjna, pola
private. - Przenieś wzory do metod, zostaw
cin/coutna zewnątrz. - Odpal dwa zestawy danych — jak w starym programie.
Ćwiczenia do samodzielnego wykonania
Folder: Dokumenty\cwiczenia-po\klasa-3\rozdzial-03.
Ćwiczenie 1. Dwa konstruktory łatwe
Punkt: domyślny (0,0) i z dwoma double. Lista inicjalizacyjna. W main dwa obiekty, wypisz przez gettery.
Ćwiczenie 2. Rozpoznaj przeciążenie łatwe
Napisz dwie funkcje wypisz: int i string. Wołaj obie z main.
Ćwiczenie 3. static ile łatwe
Klasa z konstruktorem zwiększającym static int ile. Wypisz Klasa::getIle() po utworzeniu trzech obiektów.
Ćwiczenie 4. operator+ średnie
Punkt: operator+ zwraca nowy punkt (suma współrzędnych). c = a + b w main.
Ćwiczenie 5. friend << średnie
Zaprzyjaźniony operator<< dla Punkt. W main: cout << p. Pola prywatne.
Ćwiczenie 6. Destruktor — idea średnie
Klasa z new int[n] w konstruktorze, delete[] w destruktorze. Krótki komentarz: co by się stało bez destruktora. Nie musisz pisać kopiującego, jeśli nie kopiujesz obiektów.
Ćwiczenie 7. Konstruktor kopiujący trudne
Do ćwiczenia 6 dodaj konstruktor kopiujący (głęboka kopia). Pokaż, że zmiana tablicy w kopii nie psuje oryginału. Uzasadnij w komentarzu, kiedy domyślna kopia wystarcza.
Ćwiczenie 8. Refaktor trudne
Weź program z dwiema parami boków i funkcjami pole/obwod (strukturalny). Przepisz na klasę z konstruktorami. Wyniki dla 3×4 i 5×2 mają zostać.
Sprawdź się
Wymagania na ocenę
Ocena wyższa zawiera wymagania na oceny niższe. Dotyczy konstruktorów, przeciążania, friend i static.
| Ocena | Uczeń |
|---|---|
| 2 | Definiuje prosty konstruktor. Wyjaśnia ideę destruktora. Rozpoznaje przeciążenie w gotowym kodzie. |
| 3 | Konstruktor z parametrami, tworzy obiekt. Przeciąża funkcję. Definiuje składnik statyczny według przykładu. |
| 4 | Lista inicjalizacyjna. Destruktor przy zasobie. Przeciąża operator w zadaniu typowym. Funkcja zaprzyjaźniona; odróżnia friend od dziedziczenia. |
| 5 | Konstruktor kopiujący, gdy trzeba. Metody do static. Refaktoryzuje program strukturalny do obiektowego. |
| 6 | Projektuje klasę jako typ (konstruktory, operatory, spójny interfejs). Uzasadnia friend albo jego unikanie. |