Structuri in C++

• Structurile în C++ sunt tipuri de date definite de utilizator care grupează variabile de diferite tipuri de date într-o singură unitate.
• Sunt similare cu clasele, dar cu diferențe cheie în specificatorii de acces implicit și moștenire.

Sintaxă și declarație

• O structură este declarată folosind cuvântul cheie struct urmat de numele structurii și un bloc de declarații de membri încadrat de acolade.
• Sintaxa generală este:

struct StructName {
    // Variabile membre (membri de date)
    dataType member1;
    dataType member2;
    // Funcții membre (metode)
    returnType functionName(parameters) {
        // Corpul funcției
    }
}; // Nu uitați punctul și virgulă

• Fiecare variabilă membru din structură reprezintă un atribut sau o proprietate specifică a structurii.
• Funcțiile membre definesc comportamentele sau operațiile care pot fi efectuate asupra datelor structurii.

Diferențe cheie în comparație cu clasele

• Implicit Access Specifier: În structuri, membrii sunt publici implicit. În clase, membrii sunt privați în mod implicit.
• Moștenire: Când se utilizează moștenirea, specificatorul de acces implicit pentru membrii clasei de bază este public în structuri și privat în clase.

Accesarea membrilor

• Membrii unei structuri pot fi accesați folosind operatorul punct (.).
• Dacă aveți un obiect structură, puteți accesa membrii săi astfel: objectName.memberName
• Pentru un pointer către o structură, utilizați operatorul săgeată (->): pointerName->memberName

Exemplu de structură

struct Point {
    int x;
    int y;

    void printCoordinates() {
        std::cout << "X: " << x << ", Y: " << y << std::endl;
    }
};

int main() {
    Point p1;
    p1.x = 10;
    p1.y = 20;
    p1.printCoordinates(); // Ieșire: X: 10, Y: 20

    Point *p2 = new Point;
    p2->x = 30;
    p2->y = 40;
    p2->printCoordinates(); // Ieșire: X: 30, Y: 40

    delete p2;
    return 0;
}

• În acest exemplu:
  • Point este o structură care reprezintă un punct de coordonate.
  • x și y sunt variabile membre întregi.
  • printCoordinates este o funcție membru care tipărește coordonatele.

Constructori

• Structurile pot avea constructori, la fel ca clasele
• Constructorii sunt funcții membre speciale care inițializează variabilele membre ale structurii atunci când un obiect este creat.
• Un constructor implicit (un constructor fără argumente) este furnizat automat dacă nu definiți niciun constructor.

struct Rectangle {
    int width;
    int height;

    Rectangle() { // Constructor implicit
        width = 0;
        height = 0;
    }

    Rectangle(int w, int h) { // Constructor parametrizat
        width = w;
        height = h;
    }
};

int main() {
    Rectangle r1; // Utilizează constructorul implicit
    Rectangle r2(5, 10); // Utilizează constructorul parametrizat
    return 0;
}

Metode (Funcții membre)

• Structurile pot conține funcții membre care operează asupra datelor structurii.
• Aceste funcții sunt definite în corpul structurii și pot accesa variabilele membre ale structurii.
• Exemplu:

struct Circle {
    double radius;

    double area() {
        return 3.14159 * radius * radius;
    }
};

int main() {
    Circle c;
    c.radius = 5.0;
    std::cout << "Area: " << c.area() << std::endl;
    return 0;
}

Supraîncărcarea operatorilor

• Structurile acceptă supraîncărcarea operatorilor, ceea ce vă permite să definiți un comportament personalizat pentru operatori atunci când sunt aplicați obiectelor structurii.
• Acest lucru poate face codul mai intuitiv și mai ușor de citit.

struct Complex {
    double real;
    double imag;

    Complex operator+(const Complex& other) const {
        return Complex{real + other.real, imag + other.imag};
    }
};

int main() {
    Complex c1{1.0, 2.0};
    Complex c2{3.0, 4.0};
    Complex sum = c1 + c2; // Utilizează operatorul + supraîncărcat
    return 0;
}

Cazuri de utilizare pentru structuri

• Data Structures: Structurile sunt utilizate în mod obișnuit pentru a crea structuri de date personalizate, cum ar fi liste înlănțuite, arbori și grafuri.
• Reprezentarea înregistrărilor: Utilizați structuri pentru a reprezenta înregistrări, cum ar fi înregistrări de angajați, înregistrări de studenți sau articole de inventar.
• Grouping Related Variables: Când trebuie să grupați variabile asociate, mai ales când aveți de-a face cu entități de date simple, structurile sunt adecvate.
• POD (Plain Old Data) Types: Când este necesară compatibilitatea cu codul C sau manipularea memoriei de nivel scăzut.

Structuri vs. Clase: alegerea corectă

• Utilizați o structură atunci când membrii de date sunt destinați în principal să fie publici și obiectul reprezintă o structură de date simplă
• Utilizați o clasă atunci când trebuie să impuneți încapsularea datelor, să ascundeți detaliile de implementare și să controlați accesul la variabilele membre prin metode publice.

Structuri imbricate

• Structurile pot fi imbricate în interiorul altor structuri pentru a crea structuri de date mai complexe.
• Acest lucru vă permite să organizați datele asociate în structuri ierarhice

struct Address {
    std::string street;
    std::string city;
    std::string zip;
};

struct Employee {
    std::string name;
    Address address; // Structură imbricată
};

int main() {
    Employee emp;
    emp.name = "John Doe";
    emp.address.street = "123 Main St";
    return 0;
}

Câmpuri de biți

• Structurile pot defini câmpuri de biți, care vă permit să specificați numărul de biți de alocat pentru o variabilă membru.
• Acest lucru poate fi util pentru optimizarea utilizării memoriei atunci când aveți de-a face cu valori de date mici

struct Flags {
    unsigned int flag1 : 1; // 1 bit
    unsigned int flag2 : 2; // 2 biți
    unsigned int flag3 : 3; // 3 biți
};

int main() {
    Flags f;
    f.flag1 = 1;
    f.flag2 = 2;
    f.flag3 = 5;
    return 0;
}

• Câmpurile de biți sunt adesea utilizate în programarea de nivel scăzut și atunci când se lucrează cu registre hardware.

Structuri anonime

• C++ vă permite să definiți structuri fără un nume, cunoscute sub numele de structuri anonime
• Acestea sunt utile pentru gruparea datelor asociate într-o structură sau clasă mai mare, fără a fi nevoie să creați un tip separat numit

struct Line {
  struct { // Structură anonimă
    int x;
    int y;
  } start, end;
};

int main() {
  Line line;
  line.start.x = 10;
  line.start.y = 20;
  line.end.x = 30;
  line.end.y = 40;
  return 0;
}

• Membrii structurii anonime sunt accesați direct prin structura care conține.

Uniuni în interiorul structurilor

• O structură poate conține o uniune ca membru
• Uniunile vă permit să stocați diferite tipuri de date în aceeași locație de memorie
• Structurile sunt utilizate pentru a oferi context suplimentar în jurul uniunii

struct Variant {
    enum Type {
        INT,
        FLOAT
    } type;

    union {
        int intValue;
        float floatValue;
    } data;
};

int main() {
    Variant v;
    v.type = Variant::INT;
    v.data.intValue = 42;
    return 0;
}

• Structura Variant utilizează o uniune pentru a stoca fie un întreg, fie un float, în funcție de membrul type.