Programare orientată pe obiecte

Definirea claselor

Pe lângă utilizarea tipurilor încorporate, cum ar fi int, double etc., putem defini propriile noastre tipuri sau clase. O clasă reprezintă un tip compus, care poate folosi alte tipuri.

Clasa este destinată să descrie un anumit tip de obiecte. Cu alte cuvinte, clasa este un plan al unui obiect. Iar obiectul este o implementare concretă a clasei. Se poate face următoarea analogie: cu toții avem o anumită idee despre o persoană – are un nume, o vârstă și alte caracteristici. Acest șablon poate fi numit „clasă”. O implementare concretă a acestui șablon poate diferi – de exemplu, unii oameni au un anumit nume, alții – alt nume. O persoană reală reprezintă un obiect sau o instanță a clasei.

Pentru a defini o clasă, se folosește cuvântul cheie class, urmat de numele clasei:

class nume_clasa
{
    // componentele clasei
};

După numele clasei, în acolade se plasează componentele clasei. După acolada de închidere, se pune punct și virgulă.

De exemplu, să definim o clasă simplă:

class Person { };

int main()
{
 
}

În acest caz, clasa se numește Person. De obicei, numele claselor încep cu literă mare. Să presupunem că această clasă reprezintă o persoană. Clasa este goală, nu conține niciun component, dar totuși definește un nou tip. După definirea clasei, putem crea variabile sau constante de acest tip:

class Person
{
 
};

int main()
{
    Person person;
}

Însă această clasă nu face prea multe. O clasă poate defini variabile și constante pentru a stoca starea obiectului, precum și funcții pentru a defini comportamentul acestuia. Așadar, să adăugăm în clasa Person o stare și un comportament:

#include <iostream>

class Person 
{
public:
    std::string name;
    unsigned age;
    
    void print() 
    {
        std::cout << "Name: " << name << "\tAge: " << age << std::endl;
    }
};

int main()
{
    Person person;
    // setăm valorile câmpurilor clasei
    person.name = "Tom";
    person.age = 38;
    // apelăm funcția clasei
    person.print();
}

Acum, clasa Person are două variabile name și age, care stochează numele și vârsta unei persoane. Aceste variabile sunt numite câmpuri ale clasei. De asemenea, clasa definește funcția print, care afișează valorile câmpurilor în consolă. Este important să observăm modificatorul de acces public:, care specifică faptul că variabilele și funcțiile următoare sunt accesibile din exterior, din codul principal.

Apoi, în funcția main, se creează un obiect de tip Person. Cu ajutorul punctului, putem accesa variabilele și funcțiile lui:

person.name = "Tom";
person.age = 38;

Putem de asemenea apela funcțiile obiectului:

person.print();

Ieșirea în consolă a programului este:

Name: Tom	Age: 38

În mod similar, putem obține valorile variabilelor obiectului:

#include <iostream>

class Person 
{
public:
    std::string name;
    unsigned age;
    
    void print() 
    {
        std::cout << "Name: " << name << "\tAge: " << age << std::endl;
    }
};

int main()
{
    Person person;
    // setăm valorile câmpurilor clasei
    person.name = "Bob";
    person.age = 42;
    // obținem valorile câmpurilor
    std::string username = person.name;
    unsigned userage = person.age;
    // afișăm datele obținute
    std::cout << "Name: " << username << "\tAge: " << userage << std::endl;
}

De asemenea, câmpurile clasei pot fi inițializate cu valori implicite:

#include <iostream>

class Person 
{
public:
    std::string name{"Undefined"};
    unsigned age{18};
    
    void print() 
    {
        std::cout << "Name: " << name << "\tAge: " << age << std::endl;
    }
};

int main()
{
    Person person;
    person.print(); // Name: Undefined  Age: 18
}

Pointeri către obiecte ale claselor

Putem defini pointeri către obiecte ale claselor, așa cum facem pentru alte tipuri. Prin pointer, putem accesa membrii clasei – variabile și metode. Totuși, dacă pentru accesul printr-o variabilă obișnuită folosim punctul (.), pentru pointeri folosim săgeata (->):

#include <iostream>

class Person 
{
public:
    std::string name;
    unsigned age;
    
    void print() 
    {
        std::cout << "Name: " << name << "\tAge: " << age << std::endl;
    }
};

int main()
{
    Person person;
    Person *ptr = &person;
    // accesăm câmpurile și funcțiile obiectului prin pointer
    ptr->name = "Tom";
    ptr->age = 22;
    ptr->print();
    // accesăm câmpurile obiectului direct
    std::cout << "Name: " << person.name << "\tAge: " << person.age << std::endl;
}

Modificările prin pointerul ptr se vor reflecta asupra obiectului person.