Klasy w C++: obiekty, pola i metody

Czym jest klasa

Klasa to plan własnego typu, który łączy dane (pola, czyli zmienne składowe) i zachowanie (metody, czyli funkcje składowe) w jedną całość. Wbudowane typy, takie jak int i double, opisują pojedyncze wartości, a klasa pozwala zamodelować całe pojęcie (konto bankowe, punkt 2D, gracza) jako jedną wartość, którą możesz przekazywać dalej.

Z klas korzystasz już, choć żadnej jeszcze nie zdefiniowano: std::string i kontener vector to klasy z biblioteki standardowej. Wywołanie name.length() albo v.push_back(3) to wywołanie metody na obiekcie. Teraz zbudujesz w ten sam sposób własne typy, a potem przejdziesz do konstruktorów, które je inicjalizują.

Definiowanie klasy i tworzenie obiektów

Definicja klasy wymienia składowe w klamrach i kończy się średnikiem. Zapomniany końcowy ; to jeden z najczęstszych błędów początkujących. Każdy obiekt utworzony z klasy dostaje własną kopię pól.

#include <iostream>
#include <string>
using namespace std;

class Dog {
public:
    string name;   // pole
    int age;       // pole

    void bark() {  // metoda
        cout << name << " says woof!" << endl;
    }
};

int main() {
    Dog rex;            // utwórz obiekt (instancję)
    rex.name = "Rex";   // ustaw pola operatorem .
    rex.age = 4;

    Dog luna;           // drugi, niezależny obiekt
    luna.name = "Luna";

    rex.bark();
    luna.bark();
    return 0;
}

rex i luna to dwa osobne obiekty. Zmiana rex.name nie dotyka luna.name: każdy obiekt przechowuje własne dane. Do składowej sięgasz operatorem kropki . na obiekcie (albo ->, gdy masz wskaźnik na obiekt).

public kontra private

Domyślnie wszystko w class jest prywatne: dotykać tego mogą tylko metody tej klasy. Etykieta public: otwiera składowe dla kodu z zewnątrz. Ten podział to serce enkapsulacji: udostępniasz bezpieczny interfejs i ukrywasz wewnętrzne dane, aby nie dało się ich doprowadzić do niepoprawnego stanu.

#include <iostream>
using namespace std;

class Counter {
private:
    int count = 0;            // ukryte: nikt z zewnątrz tego nie ruszy

public:
    void increment() {        // bezpieczny interfejs
        count++;
    }
    int value() const {       // const: ta funkcja nie zmieni obiektu
        return count;
    }
};

int main() {
    Counter c;
    c.increment();
    c.increment();
    cout << "Count: " << c.value() << endl;

    // c.count = 100;   // BŁĄD: 'count' jest private
    return 0;
}

Ponieważ count jest prywatne, żaden wywołujący nie przemyci ujemnej ani bezsensownej wartości: musi przejść przez increment(). const po liście parametrów value() obiecuje, że funkcja nie zmieni obiektu, dzięki czemu możesz ją wywołać na obiektach const, a czytelnik od razu widzi intencję.

Deklaracja a definicja metod

W małych klasach definiowanie metod w miejscu (jak wyżej) jest w porządku. W większych często deklaruje się metody wewnątrz klasy, a ich ciała definiuje na zewnątrz, używając składni zasięgu ClassName::method. Dzięki temu definicja klasy pozostaje czytelnym podsumowaniem interfejsu.

#include <iostream>
#include <string>
using namespace std;

class Rectangle {
public:
    double width;
    double height;

    double area() const;        // tylko deklaracja
    void describe() const;      // tylko deklaracja
};

// Definicje są na zewnątrz, z kwalifikatorem Rectangle::
double Rectangle::area() const {
    return width * height;
}

void Rectangle::describe() const {
    cout << width << " x " << height
         << " = " << area() << endl;   // może bezpośrednio wywoływać inne składowe
}

int main() {
    Rectangle r;
    r.width = 3.0;
    r.height = 4.0;
    r.describe();
    return 0;
}

Przedrostek Rectangle:: mówi kompilatorowi, do której klasy należy funkcja. Wewnątrz takiej definicji nadal odwołujesz się do składowych samymi nazwami (width, area()), a kompilator wie, że należą do obiektu, na którym wywołano metodę.

Wskaźnik this

W każdej niestatycznej metodzie this to wskaźnik na obiekt, na którym ją wywołano. Zwykle nie jest potrzebny, bo sama nazwa składowej już oznacza bieżący obiekt. Przydaje się, gdy parametr przesłania składową (mają tę samą nazwę) i trzeba je rozróżnić.

#include <iostream>
using namespace std;

class Point {
public:
    int x = 0;
    int y = 0;

    void setX(int x) {     // parametr 'x' przesłania pole 'x'
        this->x = x;       // this->x to pole; x to parametr
    }

    void print() const {
        cout << "(" << x << ", " << y << ")" << endl;
    }
};

int main() {
    Point p;
    p.setX(7);
    p.print();
    return 0;
}

Bez this-> zapis x = x; wewnątrz setX przypisałby parametr samemu sobie, a pole zostałoby nietknięte: cichy błąd. this->x usuwa niejednoznaczność. Wiele projektów całkiem omija ten problem, nazywając parametry inaczej (np. setX(int newX)), ale this-> będziesz w prawdziwym kodzie widzieć bez przerwy.

Częste błędy

Kilka pułapek związanych z klasami łapie ludzi raz za razem:

• Brak średnika na końcu. Definicja klasy kończy się };. Pomiń ;, a dostaniesz lawinę mylących błędów wskazujących na to, co jest po klasie, a nie na samą klasę.
• Zapominanie o inicjalizacji pól. Wbudowane pola, takie jak int i double, nie są automatycznie zerowane. Odczyt niezainicjalizowanego pola to niezdefiniowane zachowanie. Nadaj polom wartości domyślne (int count = 0;) albo zainicjalizuj je w konstruktorze.
• Dostęp do prywatnych składowych z zewnątrz. c.count = 5; na prywatnym polu to błąd kompilacji: użyj publicznej metody. To enkapsulacja działająca tak, jak powinna.
• Mylenie klasy z obiektem. Dog.bark(); jest błędne, bo Dog to typ. Metody wywołujesz na obiektach: rex.bark();.

// Niezainicjalizowane pole: odczyt 'age' to niezdefiniowane zachowanie:
class Cat {
public:
    int age;            // brak wartości domyślnej
};

Cat c;
std::cout << c.age;     // śmieciowa wartość, nie 0

Dalej: konstruktory

Ustawianie każdego pola ręcznie po utworzeniu obiektu (rex.name = ...; rex.age = ...;) jest żmudne i łatwo o nim zapomnieć, a tak właśnie powstają niezainicjalizowane pola. Następna strona omawia konstruktory: specjalne funkcje, które uruchamiają się automatycznie przy tworzeniu obiektu i gwarantują, że każdy obiekt startuje w poprawnym stanie, z czystą, jednolinijkową składnią Dog rex("Rex", 4);.