Structuri

Pe lângă clase, pentru a crea tipuri de date proprii, se pot folosi structuri, care sunt moștenite de C++ din limbajul C. Structura în C++ reprezintă un tip derivat de date care definește o anumită entitate, la fel ca și clasa. Adesea, structurile în contextul C++ sunt numite și clase. Și în realitate, diferențele dintre ele nu sunt foarte mari. Structura poate de asemenea să definească variabile, funcții, constructori, destructori. Totuși, de obicei, structurile sunt utilizate pentru stocarea unor date accesibile public sub formă de variabile publice. Pentru celelalte scenarii se folosesc clasele.

Pentru definirea unei structuri se utilizează cuvântul cheie struct, iar formatul de definire arată astfel:

struct nume_structura
{
    componente_structura
};

nume_structura este un identificator arbitrar, căruia i se aplică aceleași reguli ca și la denumirea variabilelor. După numele structurii, în acolade sunt plasate componentele structurii – variabile și funcții.

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

#include <iostream>
 
struct person
{
    unsigned age;
    std::string name;
};
 
int main()
{
    person tom;
    tom.name = "Tom";
    tom.age = 34;
    std::cout << "Name: " << tom.name << "\tAge: " << tom.age << std::endl;
}

Aici este definită structura person, care are două variabile: name (de tip string) și age (de tip unsigned).

După definirea structurii o putem folosi. Mai întâi putem defini un obiect al structurii – practic o variabilă obișnuită, care va reprezenta tipul creat. După crearea variabilei de tip structură, putem accesa elementele acesteia – să obținem valorile lor sau, dimpotrivă, să le atribuim alte valori. Pentru a accesa elementele structurii se utilizează operatorul punct:

nume_variabilă_structură.element

În esență, o structură este similară unei clase, adică prin structuri putem defini entități pentru utilizare în program. În același timp, toți membrii unei structuri pentru care nu este utilizat un specificator de acces (public, private) sunt în mod implicit publici (public). În timp ce într-o clasă, toți membrii pentru care nu este specificat un acces sunt privați (private).

De asemenea, putem inițializa o structură atribuind valorile variabilelor sale prin sintaxa de inițializare:

person tom{ 34, "Tom" };

Inițializarea structurilor este similară cu inițializarea array-urilor: între acolade se transmit valorile pentru membrii structurii, în ordine. Deoarece în structura person prima variabilă definită este de tip unsigned – un număr, în acolade mai întâi este plasat numărul. Și așa mai departe, pentru toți membrii, în ordine.

De fapt, orice clasă poate fi reprezentată sub forma unei structuri și invers. Să luăm, de exemplu, următoarea clasă:

#include <iostream>
  
class Person
{
public:
    Person(std::string name, unsigned age): name{name}, age{age}
    { }
    void print()
    {
        std::cout << "Name: " << name << "\tAge: " << age << std::endl;
    }
private:
    std::string name;
    unsigned age;
};
  
int main()
{
    Person bob{"Bob", 42};
    bob.print();
}

Această clasă definește entitatea „persoană” și conține un set de variabile și funcții publice și private. În locul clasei, pentru a defini aceeași entitate, am fi putut folosi o structură:

#include <iostream>
  
struct person
{
public:
    person(std::string name, unsigned age): name{name}, age{age}
    { 
    }
    void print()
    {
        std::cout << "Name: " << name << "\tAge: " << age << std::endl;
    }
private:
    std::string name;
    unsigned age;
};
  
int main()
{
    person bob{"Bob", 42};
    bob.print();
}

Și în ceea ce privește rezultatul final al programului, nu am observa nicio diferență.

Când se folosesc structurile?

De regulă, structurile sunt folosite pentru a descrie date care conțin doar un set de atribute publice – variabile deschise. De exemplu, precum structura person definită la începutul articolului. Uneori astfel de entități sunt numite și clase agregate (aggregate classes).