Definirea structurilor
Operatii cu structuri
Exercitii

Structuri

Definirea structurilor

O structura este o colectie de valori eterogene, stocate intr-o zona compacta de memorie. Componentele unei structuri, denumite campuri, sunt identificate prin nume simbolice, denumite selectori. Campurile unei structuri pot fi de orice tip, simplu sau derivat, dar nu void sau functie.

Declararea structurilor:

Declararea structurilor se face folosind cuvantul cheie struct:

struct nume_structura{
lista_campuri //declaratii de forma tip_camp_i nume_camp_i;
}lista_declaratori; //variabile de tip structura

nume_structura sau lista_declaratori pot lipsi, dar nu simultan. Daca se precizeaza nume_structura, atunci inseamna ca se face definirea tipului struct nume_structura, care poate fi apoi folosit pentru declararea de variabile, ca tip de parametri formali sau ca tip de rezultat returnat de functii:

struct coordonate{ //se declara tipul struct coordonate
float x,y;
}punct,*ppunct,puncte[20]; //variabile

struct coordonate alt_punct={1,4.5},
alte_puncte[10]={{2,4},{8},{9,7}},
mai_multe_puncte[25]={1,2,3,4};
//se pot initializa var structura la declarare;
//campurile neprecizate sunt implicit 0

struct persoana{ //se declara tipul struct persoana
char nume[20];
int varsta;
}; //lipseste lista_declaratori

struct persoana pers={"Ion Ionescu",21}, *ppers,
persoane[12];

struct{ //lipseste nume_struct
char titlu[20],autor[15],editura[12];
int an_aparitie;
}carte,biblioteca[1000]; //nu se declara un tip, deci
//doar aici pot fi facute declaratiile de variabile

Un camp al unei structuri poate fi de tip structura, dar nu aceeasi cu cea definita - se poate insa sa se declare un camp pointer la structura definita ( aspect care va fi utilizat la implementarea listelor ):

struct persoana{ //se declara tipul struct persoana
    char nume[20];
    struct{
      int zi,an,luna
    }data_nasterii; //camp de tip structura
}p;

struct nod_lista{
    tip_info info;
    struct nod_lista * urm; //camp pointer la structura
                            //definita
};

Numele de structuri se afla intr-un spatiu de nume diferit de cel al numelor de variabile - se pot declara deci variabile si tipuri structura cu acelasi nume - de evitat. Se pot declara tipuri structuri care au nume de campuri identice.

Operatii cu structuri

Selectarea unui camp al unei variabile structuri se realizeaza folosind operatorul selectie . Campul selectat se comporta ca o variabila de acelasi tip, deci i se pot aplica aceleasi prelucrari ca oricarei variabile de tipul respectiv.

variabila_structura.nume_camp

Selectia campurilor pentru variabila p de mai sus:
    p.nume //tablou de caractere
    p.nume[0] //primul caracter din nume
    p.nume[strlen(p.nume)-1] //ultimul caracter din nume
    p.data_nasterii.an
    p.data_nasterii.luna
    p.data_nasterii.an

Deoarece structurile se prelucreaza frecvent prin intermediul pointerilor, a fost introdus operatorul ->care combina cel de indirectare *cu cel de selectie. Cele doua expresii de mai jos sunt echivalente:

(*variabila_pointer).nume_camp
variabila_pointer->nume_camp

Unei variabile de tip structura:i se pot aplica operatorii & si sizeof
O variabila structura poate fi initializata la declarare prin precizarea intre {} a valorilor campurilor; cele neprecizate sunt implicit 0
O variabila structura poate fi copiata in alta variabila de acelasi tip

Cu declaratiile de mai sus:

printf("%d %d\n",sizeof(pers),sizeof(struct persoana));

ppers=&pers;

persoane[0]=*ppers; //atribuirea intre doua variabile structura

O variabila structura nu poate fi citita sau scrisa direct, ci prin intermediul campurilor
Functiile pot avea parametrii de tip structura
Tipul rezultatului returnat de o functie poate fi structura - a se studia exemplele de mai jos.

Exemple

Rezolvarea aplicatiei 3 de la lucrarea de laborator:

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <conio.h>

#define LUNG 21
#define MAX 4

typedef struct{ //a
char nume[LUNG];
float precip;
char zona;
}ORAS;

ORAS ORASE[MAX]; //c

//b
int nume_valid(char *); //tipul parametrului formal mai poate fi scris char []
//numele parametrilor formali nu e obligatoriu
//sa apara in prototip
int precip_valid(float);
int zona_valida(char);

ORAS CITIRE_ORAS(void){
ORAS o; //variabila locala ale carei campuri se citesc
while(printf("Nume oras:"),gets(o.nume),!nume_valid(o.nume));
while(printf("Cantitate precipitatii:"),scanf("%f",&o.precip),
!precip_valid(o.precip));
getchar(); //se scoate codul lui ENTER din buffer-ul de intrare
while(printf("Zona (N,S,E,V):"),o.zona=toupper(getche()),!zona_valida(o.zona));
putchar('\n');
return o;
}

/*void CITIRE_ORAS(ORAS *po){ //varianta a functiei care primeste pointerul
//la structura de citit
while(printf("Nume oras:"),gets(po->nume),!nume_valid(po->nume));
while(printf("Cantitate precipitatii:"),scanf("%f",&po->precip),
!precip_valid(po->precip));
getchar(); //se scoate codul lui ENTER din buffer-ul de intrare
while(printf("Zona (N,S,E,V):"),po->zona=toupper(getche()),
RAS,float,char); //e
//verifica si tipareste informatiile despre un oras

int TIPARIRE(float p,char z){
int i,contor;
for(i=contor=0;i<MAX;i++)
if(verif(ORASE[i],p,z))
contor++;
return contor;
}

int verif(ORAS o,float p,char z){
char c;
if((c=toupper(o.nume[0]),c!='A'&&c!='E'&&c!='I'&&c!='O'&&c!='U')
     //primul caracter din nume nu e vocala
     && o.precip>=p && o.zona==toupper(z)){
       printf("%s %f %c\n",o.nume,o.precip,o.zona);
       return 1;
}
return 0;
}

void main(void){ //e
CITIRE_ORASE();
printf("%d orase indeplinesc criteriile\n",TIPARIRE(23,'v'));
getche();
}

Carmen Holotescu
mai 2000