Vectori de structuri

De ce contează?

Un catalog de clasă are un rând per elev, iar fiecare rând conține nume, note, absențe. Nu ții numele pe o foaie și notele pe alta — ar fi un coșmar să le potrivești. Un vector de structuri e catalogul: o listă în care fiecare element ține toate datele unei entități.

De la o structură la un vector de structuri

Un vector de structuri e o listă de entități, fiecare cu toate câmpurile ei. Combini ce știi despre vectori cu ce știi despre struct:

struct Elev {
    int varsta;
    double nota;
};

Elev v[1000];      // pana la 1000 de elevi

Accesul: întâi elementul, apoi câmpul

Pentru câmpul nota al elevului i: v[i].nota. Indexul alege structura, punctul alege câmpul.

#include <iostream>
using namespace std;

struct Elev {
    int varsta;
    double nota;
};

int main() {
    int n;
    cin >> n;
    Elev v[1000];
    for (int i = 0; i < n; i++) {
        cin >> v[i].varsta >> v[i].nota;    // citim campurile elevului i
    }

    // media notelor
    double suma = 0;
    for (int i = 0; i < n; i++) suma += v[i].nota;
    cout << "Media: " << suma / n << "\n";
    return 0;
}

Observația-cheie

v[i].nota se citește „nota elevului i". Ordinea contează: v[i] selectează întâi structura, apoi .nota câmpul din ea. v.nota[i] nu are sens — v nu are un câmp nota, ci fiecare element al lui.

Avantajul: datele rămân sincronizate

Cu vectori paraleli (varsta[], nota[]), dacă rearanjezi unul fără celălalt, asociezi nota unui elev cu vârsta altuia. Cu un vector de structuri, mutând v[i] muți toate câmpurile împreună — exact ce vrei la sortare (tema următoare).

Găsirea unui element după un câmp

Elevul cu nota maximă:

int poz = 0;
for (int i = 1; i < n; i++) {
    if (v[i].nota > v[poz].nota) poz = i;
}
// v[poz] e elevul cu nota maxima

Complexitate

Operație	Timp	Spațiu
parcurgere / căutare	O(n)	O(1)
acces la `v[i].camp`	O(1)	—

Greșeli frecvente

Capcane reale la vectorii de structuri:

Ordinea acces: v[i].camp, nu v.camp[i]. Întâi elementul, apoi câmpul.
Compari structura întreagă: if (v[i] > v[j]) nu merge implicit — compari un câmp anume (ex. v[i].nota), sau definești un criteriu.
Vectori paraleli din obișnuință: revii la nota[]/varsta[] și pierzi sincronizarea la rearanjări. Ține-le într-un struct.
Depășești dimensiunea: la fel ca la orice vector, i < n și dimensiune suficientă.

De reținut

Vector de structuri = listă de entități, fiecare cu toate câmpurile ei.
Acces v[i].camp (întâi elementul, apoi câmpul); parcurgere O(n), acces O(1).
Datele unei entități rămân împreună → sincronizare garantată la sortare.