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
Kiedy bez argumentów 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
}
Ślad 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[].
Reguła trzech (na razie) Jeśli piszesz destruktor, zwykle potrzebujesz też konstruktora kopiującego (i operatora przypisania — na sali wystarczy unikać 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).

Nie przeciążaj na siłę + 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.

friend psuje hermetyzację lokalnie To świadomy wyłom: ktoś spoza klasy rusza prywatny stan. Jeśli wystarczy getter — getter jest czytelniejszy i nie otwiera drzwi na oścież. Nie myl z dziedziczeniem: nauczyciel nie jest „przyjacielem” pracownika, tylko jego specjalizacją.

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”.

Ślad Przed 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.
Nie myl z lokalnym static 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.

Kolejność przestawiania
  1. Wypisz atrybuty i metody na kartce (wzór klasy).
  2. Konstruktor + lista inicjalizacyjna, pola private.
  3. Przenieś wzory do metod, zostaw cin/cout na zewnątrz.
  4. 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ę

1. Lista inicjalizacyjna konstruktora:
2. Destruktor jest potrzebny zwłaszcza gdy:
3. Przeciążenie funkcji to:
4. Pole static:
5. friend a dziedziczenie:

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.

Lista „już umiem”