STRUCTURI

Def: O structura este o colectie de una sau mai multe variabile grupate sub un acelasi nume.
Variabilele intr-o structura, spre deosebire de cele dintr-un array, pot fi de diferite tipuri. O structura poate
contine orice tip de date, inclusiv alte structuri sau array-uri, mai puin declaraii ce implica recursivitate.
Fiecare variabila dintr-o structura se numeste membru al structurii.
Ex de structura numita coord, care are ca si membrii coordonatele unui punct :
struct coord {
int x;
int y;
};
Obs. Caracterul ; este obligatoriu dp declararea unei structuri.
Cuvantul cheie struct indica inceputul definirii unei structuri. Acesta trebuie urmat de numele structurii.
Intre acolade se declara membrii structurii. Fiecare membru tebuie sa aiba specificat tipul. Exemplul de mai
sus defineste un tip structura care contine doua variabile de tip intreg x,y, dar nu creeaza nici un fel de
instantiere. Sunt doua posibilitati de a declara o structura (de a rezerva spatiu de memorie pentru membrii
structurii) :
1.
struct coord {
int x;
int y;
} first, second;
first si second declara 2 structuri de tip coord. Asta inseamna ca first contine doi membrii de tip intreg ,
adica pe x si pe y si la fel si second.
2.
struct coord {
int x;
int y;
};
/* optional poate fi scris cod, declararea fiind posibila pe parcursul
programului */
struct coord first, second;
typedef struct{
int x;
int y;
}coord;
coord first, second;
Accesarea membrilor unei structuri:
Membrii unei structuri sunt accesati prin operatorul . (operatorul de selecie). Acesta se pune intre numele
structurii si numele membrului. De exemplu, daca vrem sa atribuim lui x valoarea 50 si lui y valoarea 100,
apartinand structurii first vom scrie :
first.x = 50;
first.y = 100;
Pentru a ne convinge ca atribuirea s-a efectuat, putem sa afisam coordonatele in felul urmator:

printf("%d,%d", second.x, second.y);

Un avantaj major care este oferit de folosirea structurilor in locul folosirii de simple variabile este copiera
de informatii dintre structurile de acelasi tip printr-o simpla atribuire :
first = second;

(echivalent cu)

first.x = second.x;
first.y = second.y;

Un alt avantaj pe care structurile il ofera este acela de a putea accesa un grup de diferite tipuri de variabile.
De exemplu, daca dorim sa avem o baza de date la care fiecare intrare sa fie o structura care sa aiba ca
membri mai multe informatii (nume, adresa, telefon), acestea constituind membrii structurii.
Ex de structura cu instantiere :
struct date {
char month[2];
char day[2];
char year[4];
} current_date;
Ex de declarare si initializare a unei structuri :
struct time {
int hours;
int minutes;
int seconds;
} time_of_birth = { 8, 45, 0 };
Structuri care contin alte structuri
Sa presupunem ca dorim sa fixam cooronatele unui dreptunghi. Pentru aceasta avem nevoie de doua puncte
care vor reprezenta colturile de pe diagonala dreptunghiului. Fiecare colt este definit prin doua coordonate
x si y. Pentru a ne referi la x si y (coordonatele unui punct), facem apel la structura de mai sus coord.
In continuare definim o alta structura care are ca si membrii doua structuri de tip coord,fiecare
reprezentand cate un punct al diagonalei dreptunghiului :
struct rectangle {
struct coord topleft;
struct coord bottomrt;
};
Pentru a declara aceasta structura, exemplificam inca o data cele doua metode expuse mai sus :
1.
struct rectangle {
struct coord topleft;
struct coord bottomrt;
} mybox;
2.
struct rectangle mybox;
Accesarea punctelor x si y se face in felul urmator :

mybox.topleft.x = 0;
mybox.topleft.y = 10;
mybox.bottomrt.x = 100;
mybox.bottomrt.y = 200;
Structuri care contin tablouri (array-uri)
Ex de definire de structura care are ca si membrii 2 tablouri de tipuri diferite
struct data{
int x[4];
char y[10];
};
Ex de declarare a acestei structuri :
struct data record;
Ex de accesare a membrilor ei :
record.x[2] = 100;
record.y[1] = `x';
Tablouri de structuri
Sa presupunem ca dorim sa retinem numele si numarul de telefon al unor persoane. Pentru aceasta definim
o structura :
struct entry{
char fname[10];
char lname[12];
char phone[8];
};
Apoi declaram un tablou numit lista care contine 1000 de elemente. Fiecare din aceste elemente va fi o
structura de tip entry :
struct entry list[1000];
Rezultatul obtinut este un tablou de structuri. Se pot face diferite operatii intre membrii structurilor. Spre
exemplu putem atribui un element al tabloului altui element :
list[1] = list[5];
Prin exemplul de mai sus am atribuit fiecarui membru al structurii list[1] valorile care sunt la list[5]. De
asemenea se pot copia date intre membrii structurilor :
strcpy(list[1].phone, list[5].phone);
Obs: Variabila phone a fost declarata de tip char, de aceea trebuie folosita functia strcpy().
Structuri si pointeri
Pointerii pot fi folositi pe de o parte ca si membri ai unei structuri, dar si pentru a accesa o structura
(pointeri la structuri)

Pointeri ca membri ai structurii

Nu sunt diferente intre declararea pointerilor in afara structurilor fata de declararea lor ca si membrii ai
structurii :
Ex de structura care are ca si membrii pointeri la intregi :
struct data {
int *value;
int *size;
} first;
Obs. Structurile care conin pointeri NU este indicat sa fie doar atribuite.
Am definit si declarat o structura cu doi mebri pointeri la intregi. Acestia trebuie sa pointeze (sa indice)
catre ceva:
first.value = &cost;
first.size = &volume;
Expresia *first.value evalueaza valoarea lui cost, precum si expresia *first.size evalueaza valoarea lui
volume.
Ex cu membrii pointeri la char:
struct msg {
char *p1;
char *p2;
} myptrs;
myptrs.p1 = "Intelegem structuri";
myptrs.p2 = "Invatam structuri";
EX: Afisare:
printf("%s %s", myptrs.p1, myptrs.p2);
Pointeri la structuri
Pointerii la structuri sunt cel mai adesea folositi atunci cand dorim sa transmitem o structura ca si
parametru intr-o functie sau la liste inlantuite, capitol ce va fi tratat ulterior.
Ex de pointer la structura :
struct part {
int number;
char name[10];
};
struct part *p_part;
Obs : Operatorul de dereferentiere * de mai sus indica faptul ca p_part este un pointer catre tipul part, nu
o instantiere a tipului part. Pointerul are nevoie de o adresa de memorie spre care sa indice. Din acest motiv
este necesar sa declaram o instanta de tipul part :
struct part inst;

Acum putem face initializarea pointerului:

p_part = &inst;
Aceasta operatie atribuie adresa lui inst la p_part. Am obtinut un pointer catre structura inst. O metoda de
acces la structura este prin folosirea operatorului de indirectare * . Din moment ce p_part este un pointer
catre structura inst => *p_part se refera la inst.
Pentru a ne referi la mebrii individuali ai structurii inst :
1. putem aplica operatorul ..
Ex de atribuire mebrului inst.number, valoarea 100 :
(*p_part).number = 100;
Obs : *p_part trebuie pus intre paranteze deoarece operatorul . are precedenta mai mare decat *.
2. folosind operatorul -> Acest operator este plasat intre numele pointerului si numele membrului.
Ex de accesare a membrului number din inst cu ajutorul lui p_part:
p_part->number
Presupunem ca str este o structura, p_str este un pointer catre str si memb este un membru al str.
Putem accesa str.memb in felul urmator :
p_str->memb
Obs: Daca p_str este un pointer la structura str. Urmatoarele expresii sunt echivalente :
str.memb (*p_str).memb p_str->memb
Pointeri si tablouri de structuri
Pentru exemplificare, o sa plecam de la un exemplu folosit anterior:
struct part {
int number;
char name[10];
};
Dupa ce am definit structura part, putem sa declaram un array de tipul part.
struct part data[100];
In continuare putem sa declaram un pointer la tipul part si sa-l initializam sa pointeze spre prima
structura din tabloul data.
struct part *p_part;
p_part = &data[0];
Pentru a afisa membrii, putem sa scriem in urmatorul mod:
printf("%d %s", p_part->number, p_part->name);

Alocare dinamica a structurilor

Presupunem ca avem urmatoarea structura :
typedef struct {
int number;
char *string;
}myStruct1;
Pentru a aloca dinamic spatiu pentru aceasta structura folosim una din functiile de alocare deja invatate.
Spre exemplu cu ajutorul lui malloc:
myStruct1 *name = (myStruct1 *) malloc(sizeof(myStruct1));
Bineinteles ca nu trebuie neglijat nici testul de alocare:
if (name == NULL) {
printf("out of memory\n");
exit(1);
}
Accesul la membrii structurii se face la fel ca si in exemplele de mai sus:
name->number=10 ;
name->string= Alocare dinamica a structurilor;
Obs: Nu uitati sa eliberati memoria!
free(name);
Putem aloca in mod dinamic spatiu si pentru un membru al structurii. Exemplul de mai jos ilustreaza un
mod in care s-a alocat spatiu pentru membrul string.
char *sir= Alocare dinamica a unui membru;
name->string=(char *) malloc (strlen (sir )+1);
strcpy(name->string,sir);
Functii care au ca si argument structuri
Acest lucru este ilustrat in exemplul de mai jos :
#include <stdio.h>
/* Defineste si declara o structura */
struct data{
float amount;
char fname[30];
char lname[30];
} rec;
/* Prototipul functiei. Nu are valoare returnata si are un argument de
tip structura */

void print_rec(struct data x);

void print_rec_2(struct data *x);
main()
{
/* Citirea datelor de la tastatura. */
printf("Enter the donor's first and last names,\n");
printf("separated by a space: ");
scanf("%s %s", rec.fname, rec.lname);
printf("\nEnter the donation amount: ");
scanf("%f", &rec.amount);
/* Apelarea functiei print_rec(). */
print_rec( rec );
print_rec_2( &rec );
/* Obs :apelul
structurii*/

se

face

avand

ca

si

argument

numele

dat

instantei

return 0;
}
void print_rec(struct data x)
{
printf("\nDonor %s %s gave $%.2f.\n", x.fname, x.lname,
x.amount);
}
void print_rec_2(struct data *x)
{
printf("\nDonor %s %s gave $%.2f.\n", x->fname, x->lname,
x->amount);
}
Ex de program care acceseaza elemente succesive ale unui array prin incrementarea unui pointer :

#include <stdio.h>
#define MAX 4
/*Definirea unei structuri, apoi declararea si initializarea unui
tablou cu 4 structuri*/
struct part {
int number;
char name[10];
} data[MAX] = {{1, "Smith"},
2, "Jones",
3, "Adams",
4, "Wilson"
};

/* Declararea unui pointer de tip part si a unui intreg pentru numarul

de variabile*/
struct part *p_part;
int count;
main()
{
/* Initializarea pointerului la primul element al tabloului*/
p_part = data;
/*Parcurgerea tabloului prin incrementarea pointerului la fiecare
iteratie */
for (count = 0; count < MAX; count++)
{
printf("At address %p: %d %s\n", p_part, p_part->number,
p_part->name);
p_part++;
}
}

return 0;

Probleme propse :
1.
Propuneti o structura care sa contina toate campurile necesare unei inregistrari din cartea de telefon.
Motivati utilizarea si definirea campurilor respective.
2.
Se cere proiectarea unei baze de date care sa contina poligoane neregulate inchise in plan. Se vor initializa
Un numar de 7 poligoane cu numarul de laturi intre 3 si 10, iar in final pentru fiecare poligon se va afisa
perimetrul.
3.
Sa se argumenteze crearea unei baze de date folosind structuri, necesare unui campionat de fotbal in care
sa fie incluse jucatorii, echipele si meciurile.
4.
Se considera mai multe orase, fiecare oras putand dispune sau nu de unul din urmatoarele atribute :
- patinoar (7-35)
- opera (15-70)
- muzeu (15-60)
- stadion (10-40)
- monumente (30-70)
- mall (3-30)
- strand (10-20)
- cinema (14-30)
- parc (40-70)
- discoteca (15-25)
Numerele din paranteza reprezinta intervalul de varsta pentru care proprietatea respectiva prezinta interes.
Orasele se introduc de la taspatura, pentru fiecare oras dandu-se 2 linii : pe prima linie, numele orasului iar

pe a 2-a un sir format din 0 si 1 fara pauze, de 10 caractere, 0 reprezentand absenta proprietatii, iar 1
prezenta ei in oras. Lista de orase se incheie la prima linie vida. Dupa ce s-au introdus orasele, se vor
introduce pe rand numere reprezentand varste. Pentru fiecare varsta introdusa, sa se afiseze primele 3 orase
cele mai atractive pentru acea varsta si gradul lor de atractivitate. Gradul de atractivitate este dat de
numarul proprietatilor prezente in oras, care reprezinta atractie pentru varsta data.
5.
Scrieti o functie care atribuie o structura alteia, structura fiind definita in felul urmator: struct
o_structura{int x; char h; char *f}; si cunoscandu-se ca f arata spre un sir de caractere neconstant!