STRUCTURI DE

DATE

Lucrare de atestat la informatică

 CUPRINS

Declarare/definire
Aplicarea operatorului „typedef”
Accesul la membrii structurii
Operatorul „sizeof” aplicat structurilor
Pointeri la structuri
Câmpuri de biţi
Tablouri de structuri
Atribuiri de structuri de acelasi tip
Structurile ca tip de argumente sau tip întors de funcţii
 Funcţii ce preiau structuri
 Funcţii ce întorc structuri

Bibliografie

2
  Declarare/definire
Structura este un grup de variabile reunite sub acelaşi nume, ce pune la
dispoziţia utilizatorului un mod convenabil de păstrare a informaţiilor legate
între ele.
Structurile se deosebesc de tablouri prin următoarele aspecte:
 elementele unei structuri pot avea tipuri diferite
 structurile pot fi atribuite
 funcţiile pot returna structuri
 elementele unui structuri nu sunt variabile anonime ci au câte un nume.
 referirea unui element al unei structuri se realizează cu operatorul de selecţie
( . ) şi nu cu operatorul de indexare ( [ ] ).
Declararea unei structuri creează un nou tip de date ce poate fi folosit
pentru a crea variabile de acel tip sau pentru a crea direct variabile de acel tip.
Variabilele care fac parte din structură se numesc membri, elemente sau câmpuri
ale structurii. între membrii structurii de obicei există o legătură logică.
Forma generala a declarării unei structuri este:
struct nume_generic {
tip nume_membrul_l; tip nume_membrul_2;
……………………..
tip nume_membrul_n;
} lista_variabile;
unde:
struct - este cuvânt rezervat, numele tipului de date;
tip - este orice tip de dată admis de C; nu trebuie să fie acelaşi pentru
toate câmpurile;
nume_generic - numele dat noului tip de date, opţional;
listă_variabile - este o listă de variabile de tip numegeneric daca apare
sau anonim daca nu apare, este opţională;
nume_membru_i - este numele câmpului (membralui) i al structurii.
Nume_generic şi listă_variabile sunt opţionale, dar cel puţin una trebuie
sa apara. Dacă nume_generic apare înseamnă că s-a creat un nou tip de date.

3
Dacă
apare numai lista_variabile înseamnă ca s-au declarat variabile de tip structură,
fară ca structura să aibă tip (tipul structurii create este anonim).
Exemplu:
struct carte {
char nume_carte [30];
char nume_autor [40];
char editura [20];
long data_ap;
unsigned char ed; //editia} cartel, carte2;

unde : carte este tipul structurii, variabilele de tip structură sunt carte1 şi
carte2.
Odată definit un tip de structură, se pot crea mai multe variabile de acel tip,
folosind forma generală: struct nume_generic lista_variabile;

Declaraţia de mai sus se poate rescrie astfel:

struct carte { char nume_carte[30];
char nume_autor[40];
char edi tura[2 0];
long data_ap;
unsigned char ed; //editia
} carte 1, carte 2;
Deci nu este necesar să se declare toate variabilele de tipul respectiv
atunci când este definită o structură. Variabilele se pot declara separat, pe măsură
ce apare necesitatea folosirii lor.
În cazul în care se ştiu exact variabilele de tip structură folosite în
program, „nume_generic” poate lipsi. De exemplu, dacă programul va folosi
doar variabilele „cartel”, „carte2” si „carte3” în cadrul programului putem declara
structura astfel:
struct {char nume_carte[30];
char nume_autor[40];
char editura[20];
long data_ap;
unsigned char ed;
float pret; } cartel, carte2, carte3;
unde lipseşte numele tipului structurii create.

Reguli ale câmpurilor:

Câmpurile unei structuri nu pot fi de tip void sau functii.
De asemenea nu pot fi structuri de acelaşi tip cu tipul structurii în care

4
apar, dar se permite existenţa unui pointer către o structură de acelaşi tip cu cea în
care apare pointerul. Situaţia aceasta este întâlnită în cadrul tehnicilor de
programare, unde implementarea tipurilor de date abstracte - lista, stiva, coada,
arbore ş.a - fac apel la liste de structuri, în care fiecare structură a acelei liste
poate puncta către structura vecină din dreapta - listă simplu înlănţuită, sau şi
către cea din dreapta şi către cea din stânga - listă dublu înlănţuită.
Sintaxa la declarare/definire este aceeaşi cu a variabilelor obişnuite, doar că nu
pot fi iniţializate.

 Aplicarea operatorului ,,typedef”

Se poate lucra cu o structură în declararea de variabile de acel tip al

structurii folosindu-ne de cuvântul-cheie struct urmat de identificatorul acelei
structuri, după care numele de variabile. Mai comod este să înlocuim combinaţia
struct-tag printr-un singur nume, definit folosind typedef. Este foarte utilă
folosirea lui typedef în situaţia unor tipuri de date mai complexe, compuse din
tipuri mai mici. Se asigură astfel o flexibilitate in lucru.
Definiţia de tip folosind typedef este o instrucţiune, deci se încheie cu
punct şi virgulă.
Sintaxă:
typedef struct numeStructura{
tip1 numeVar_1 ;
tip1 numeVar_2 ;
...
tip1 numeVar_3 ;
} TIP_STRUCTURA ;

După cum se vede am definit un nou tip, TIP_STRUCTURA, asociat

construcţiei de tipul: struct numeStructura.

Oriunde puteam folosi combinaţia “struct numeStructura” putem acum

folosi direct „TIP_STRUCTURA”. Compilatorul caută în primă fază dacă prin
fişierele header incluse în acel program există definită o constantă sau un tip cu
denumirea respectivă. Dacă da, înlocuieşte denumirea cu definiţia asociată. Dacă
nu există nimic în fişierele header, caută în fişierul program curent dacă există o
definiţie de constantă sau de tip dată de utilizator pentru numele respectiv. În caz
că găseşte aşa ceva face înlocuirea, iar dacă nici aici nu găseşte nimic generează
semnal de eroare: "Unknown identifier ...".

Exemplu:
1. typedef struct persoana{

5
 char prenume[15] ;
char nume[15] ;
int varsta ;
} PERSOANA ;

2. typedef struct{
char prenume[15] ;
char nume[15] ;
int varsta ;
} PERSOANA ;

Se poate observa că din moment ce vom defini un nou tip de structură,

identificatorul acesteia poate sau nu să apară în definiţia de tip. În prima variantă
din exemplu apare, iar în cea de-a doua nu.

 Accesul la membrii structurii

Pentru a accesa direct un cămp al unei structuri, trebuie specificate atât numerele
variabilelor de tip structură cât şi numele câmpului, separate printr-un punct.
Forma generala de acces la un membru:
nume_variabil.nume_membru
unde nume_variabila este numele variabilei de tip structura, iar
nume_membru este numele campului ce se doreste a fi accesat.
Pentru structura şi variabilele declarate mai sus putem realiza următoarele operaţii:
- atribuirii de forma:
cartel.data_ap = 1999;
carte2.editura = "Teora";
cartel.nume_carte = "Programare în C";
cartel.preţ = 12345.50;

- citirea unor câmpuri ale unei structuri :

scanf("%ld%f%s", &cartel.data_ap, &cartel.preţ, cartel.editura);
gets (cartel.nume_carte);

- scrierea / afişarea unor câmpuri ale unei structurii:

printf("%ld%f%s", cartel.data_ap, cartel.preţ, cartel.editura);

- afişarea un caracter dintr-un câmp:

printf( "%c", cartel.nume_autor[5] );

- atribuirea unei variabile a unui caracter dintr-un câmp:

6
ch= cartel.nume_autor [5]);

- conţinutul unei variabile de tip structură poate fi asignat unei alte variabile
de tip structură, dar de acelasi tip:
carte2 = cartel;
atribuire echivalentă cu atribuirile:
carte2.nume_autor = cartel.nume_autor; carte2.nume_carte = cartel . nume_carte;
carte2.editura = cartel.editura;
…………………………….
carte2.preţ = cartel.pret;

- determinarea dimensiunii unei structuri folosind operatorul sizeof:

printf("Numărul de octeţi ai structurii = %d",sizeof(struct carte));
Numele tipului structurii trebuie să fie precedat de cuvântul cheie struct la
folosirea operatoralui sizeof(): printf (" dim=%d\n", sizeof(struct carte) );
Observaţie:Pentru a asigura portabilitatea unui program ce conţine
structuri este obligatorie folosirea operatorului sizeof(). Se asigură astfel că
dimensiunea în memorie este mereu folosită aşa cum trebuie.
Numele câmpurilor unei structuri nu intră în conflict cu alte variabile cu
acelaşi nume.
#include<stdio.h>
void main() {
struct alfa { int x, y;} beta;
int x=123;
beta.x=75;
beta.y=-125;
printf (" %d %d %d", x, beta.x, beta.y);
}

 Operatorul „sizeof” aplicat structurilor

Colecţia de tipuri neomogene pe care o constituie structura aduce şi
probleme de spaţiu alocat.
Familia de microprocesoare 80x86 permite o serie de tipuri de date native:
BYTE, WORD, DOUBLE WORD, TEN BYTES. Fiecare dintre acestea este
multiplu de o putere a lui 2. Astfel WORD este multiplu de 16, DOUBLE WORD
de 32 ş.a.m.d. Această multiplicitate impune, în situaţiile de aliniere în memorie,
situarea datelor la adrese care respectă puterile lui 2 menţionate. Există
posibilitatea ca anumite zone de memorie să rămână neocupate, fiind forţată
aşezarea la altă adresă decât cea care ar urma.
Acest lucru se poate întâmpla şi în cazul structurilor, unde tipurile diferite

7
pot fi "aşezate" diferit în memorie. De aceea, pentru a şti exact spaţiul alocat
trebuie folosit operatorul sizeof().

Sintaxă:
sizeof (struct tip) ; /* fără typedef.*/
sau
sizeof (tipStructura) ; /* cu typedef.*/

Exemplu : typedef struct printer{

char producator :
int rezOrizontal ;
int rezVertical ;
int nrPagPerMin_Negru ;
int nrPagPerMin_Color ;
float pret ;
} IMPRIMANTA ;
IMPRIMANTA hp ;
int nrOcteti = sizeof(IMPRIMANTA) ;
printf("\n Numarul de octeti ai structurii: %d", nrOcteti) ;

Observaţie:
Pentru a asigura portabilitatea unui program ce conţine structuri este
obligatorie folosirea operatorului sizeof(). Se asigură astfel că dimensiunea în
memorie este mereu folosită aşa cum trebuie.

 Pointeri la structuri
Accesarea unei structuri printr-un pointer este o tehnică uzual folosită în
C.
• Declararea unui pointer la o structură
Un pointer la o structură se declară prin plasarea operatorului * în faţa
numelui variabilei de tip structură.
De exemplu declaraţia:
struct alfa {
char x;
int y;
char s [ 10];
} beta, *gama;

este echivalentă cu:

struct alfa {
char x;
int y;
char s [ 10];

8
 } beta; struct alfa *gama;
unde gama este pointer către structura alfa.

Instrucţiunea „gama=&beta;” asignează lui gama adresa structurii beta.

• Utilizarea pointerilor la structuri (generarea unei apelări de

funcţie prin parametrii de tip referinţă)
Declararea unui pointer către o structură se face în acelaşi fel în care se
declară un pointer către oricare alt tip de variabilă. De exemplu:
struct alfa { int a;
float b;
char s[40]; } beta, *p; struct alfa *g;
Pentru a găsi adresa unei variabile de tip structură, se plasează operatorul
de adresă & înaintea numelui acesteia: p=&beta;
g=p;/* asignează pointeralui g adresa variabilei de tip structură beta, prin
intermediul pointerului p;*/ Pentru a avea acces la câmpurile structurii folosind un
pointer la aceasta, trebuie utilizat operatorul săgeată (->), operator compus din
semnul minus şi semnul relaţional mai mare.
De exemplu accesul la câmpul b al structurii beta, prin intermediul
pointerului p se face prin constructia:
p->b = 7 . 2 5 ;
Săgeata se foloseşte în locul operatoralui punct pentru a accesa un câmp al
unei structuri prin intermediul unui pointer la aceea structură. Dacă structura este
de dimensiuni mari, transferul ei poate conduce la o reducere considerabilă a
vitezei de execuţie a programului. Se recomandă ca să se transfere funcţiei un
pointer către o structură şi nu structura însăşi.
Observaţie. Operatorul punct se foloseşte pentru accesarea unui câmp al unei
structuri pentru o variabilă de tip structură, iar operatorul săgeată se foloseşte
pentru accesarea unui câmp al unei structuri printr-un pointer.
Exemplu: #include<stdio.h>
#include<string.h>
struct alfa{ char a;
int x;
float f;
char sir[30];
} beta;
struct alfa *p;
void main(void){
p=&beta;
beta.f=-75.33
p->=-75.33
strcpy(p->sir, „se mai copiaza in sir”)
print f(„%f %f %s, beta.f, p->f, p->sir”);
}

Exemplu. Realizarea unui program ce simulează un ceas ce afişează pe ecran

orele, minutele şi secundele.

9
 include <stdio . h>
define DELAY 128000
struct ceas {
int ora;
int minute;
int secunde; } ;
void afiseaza(struct ceas *p);
void calc(struct ceas *p);
void intirziere(void);
void main(void){
struct ceas curenta;
curenta.ora=0;
curenta.minute=0;
curenta.secunde=0;
for ( ; ; ) { calc(&curenta);
afişeaza(&curenta); }
}

void calc (struct ceas *p) {

p->secunde++;
if (p->secende==60){ p->secunde=0;
p->minute++; }
if(p->minute==60){ p->minute=0;
p->ora++; }
if(p->ora==24) p->ora=0;
intraziere();
}
void afişeaza (struct ceas *p) {
printf("%2d:%2d:%2d\n",p->ore,p->minute, p->secunde); }

void întarziere(void) {
long int p;
for (p=l; p<DELAY; p++;) }

Structura ceas este definită ca structură globală. In funcţia main() s-a

declarat variabila structură curentă şi câmpurile sale au fost iniţializate cu zero.
Funcţiile calc() şi afişeaza() primesc adresa structurii curentă. Cele două
funcţii au ca argument un pointer la structură de tip ceas.
Accesul la fiecare câmp al structurii curentă se realizează printr-un
pointer.

10
  Câmpuri de biţi
Limbajul C, prin tipul de date câmpuri de biţi, permite accesul la unul sau
un grup de biţi, dintr-un octet sau cuvânt (doi octeţi).
Pentru a avea acces la biţi, limbajul C foloseşte o metodă bazată pe tipul
structura, în fapt, un câmp de biţi este efectiv chiar un tip special de membru al
unei structuri căruia i se specifică tipul si numărul efectiv de biţi. Forma generală
de definire a unui câmp de biţi este:
struct nume_generic { tip nume1:lungime;
tip nume2 : lungime;
………………
tip numen: lungime
} lista_variabile;
unde:
nume_generic - este numele tipului de dată creat;
tip - este tipul câmpului nume de biţi şi care trebuie să fie de tip int, unsigned
sau signed. Câmpul de lungime unu trebuie să fie declarat ca fiind unsigned
deoarece un singur bit nu poate avea semn.
lungime - reprezintă numărul de biţi ai câmpului nume.
Dacă un câmp de biţi este specificat ca int sau signed, bitul cel mai
semnificativ va fi bitul de semn. Numele câmpului de biţi nume i şi lungimea sa
sunt separate prin două puncte (:).
Câmpurile de biţi sunt utile în următoarele situaţii:
- dorim să înmagazinăm mai multe informaţii, de obicei de tip
boolean (adevărat/fals) într-un spaţiu cât mai mic;
- pentru a transmite informaţii codificate unor echipamente;
- pentru a cripta informaţii într-un octet sau cuvânt. De exemplu:

struct camin {
unsigned camere:4 ; //pana la 15 camere
unsigned stare:l ; // ocupate 1, libere 0
unsigned plata:l ; // 1 plătit, 0 restanţă
unsigned perioada: 2; //perioada in luni închiriată }
agronomie[3],lapuş;
Toate aceste informaţii sunt stocate într-un singur octet (4 + 1 + 1 + 2 = 8
biţi). în mod normal dacă nu se folosea câmpul de biţi, ar fi fost necesar minim 4
octeţi. Un membru al unui câmp de biţi poate fi accesat ca orice element al unei
structuri.
De exemplu instrucţiunea „agronomie[ 2 ] .camere=14;” asignează
valoarea 14 câmpului camere a articolului 3 din tabloul de structuri
agronomie[3].
Sau instrucţiunea:
if (lapus.stare) printf("camera este ocupată");
else printf ("camera este liberă");

11
 Nu este necesar ca biţii dintr-un octet sau cuvânt să fie toţi ocupaţi.
struct alfa {
int x: 10;
int y: 2; };
Compilatorul stochează structura definită câmp de biţi pe cea mai mică
unitate de memorie octet sau cuvant în o aceeaşi structură pot coexista atât
câmpuri de biţi cât şi variabile normale, membri ai structurii.
struct blocuri {
char bloc[10]; //nume bloc
float plata; // cheltuieli lunare
unsigned achitat: 1; //1 - da, 0 - nu
unsigned intarziere : 3; //număr de luni
} cartier[4];

Dacă accesul la structură se face printr-un pointer, se va folosi operatorul

săgeată(->)

struct alfa{
unsigned x: 3;
unsigned y: 2; }beta, *p;
p=&beta;
p->x=5; / * atribuie valoarea 5 câmpului x a variabilei structură beta
*/

Nu este necesar a se da nume tuturor biţilor dintr-un câmp de biţi:

struct stare {
unsigned x: 1;
unsigned: 4;
unsigned y : 2;
};
Observaţie. Variabilele de tip câmp de biţi sunt supuse unor restricţii. De exemplu
nu se poate obţine adresa unui membru al unui câmp de biţi, adică nu se poate
folosi operatorul de adresă &.

 Tablouri de structuri
Structurile pot fi aranjate în tablouri la fel ca celelalte tipuri de date. De
exemplu următoarea declaraţie creează un tablou unidimensional CARTE[20] de
structuri de tip carte, ce conţine 20 de elemente:
struct carte CARTE[20];

Pentru a accesa o anumită structură din tablou, numele tabloului trebuie

indexat.

CARTE[0] - permite accesul la prima componentă a tabloului de structuri, sau

CARTE[19] - permite accesul la ultima componentă a tabloului de structuri.

12
 Pentru a accesa un câmp al unei anumite structuri din tablou, indexul
trebuie urmat de punct şi de numele câmpului dorit. De exemplu:
gets (CARTE[3].nume_autor)
CARTE[3].data_ap=1998
printf (preţul cărţii este : %f”, CARTE[3] .preţ);
printf („Al 3-lea caracter al celei de-a 3-a carte este %c,
CARTE[2].nume_carte)
etc.
La toate tablourile si la tablourile de structuri indicii încep de la 0.

• Transmiterea structurilor ca parametri unei funcţii. Structurile si membri

structurilor pot fi transferate ca parametri funcţiilor, iar o funcţie poate să
returneze o structură.
• Transmiterea membrilor structurilor ca parametri unei funcţii. Unei funcţii i se
poate transmite valoarea sau adresa unui membru al unei structuri.
Exemplu: Fie structura: struct alfa{ char x;
int y;
float z;
char s[10]; } beta, gama;
Următoarele apeluri transferă valoarea unor membri ai structurii:
f i (beta. x) ; / * transferă valoarea de tip caracter din câmpul x */
f 2 (beta. z) ; / * transferă valoarea de tip float din câmpul z */
f 3 (beta. s) ; / * transferă adresa şirului s */
f 4 (beta. s [ 5]); / * transferă valoarea de tip caracter din s[5] */
Dacă doriţi să transmiteţi adresa unui membru individual al structurii
trebuie plasat operatorul de adresă & înaintea numelui structurii.
gi (&gama. x); /* transferă adresa caracteralui x */
g2 (& gama. y); /* transferă adresa întregului y */
g3 (&gama. s); /* transferă adresa şirului s */
g4 (&gama. s [ 5 ]) ; /* transferă adresa caracterului s[5] */
Operatorul & precede numele variabilei structură, nu pe cel al campului.
Pentru că s, numele sirului, este deja o adresă, nu necesită prezenţa operatorului &.
• Transmiterea structurilor ca parametrii unei funcţii
Dacă o structură este folosită ca argument al unei funcţii, întreaga
structură este transmisă folosind metoda de apelare prin valoare. Aceasta
înseamnă că orice modificare a conţinutului structurii din interiorul funcţiei
căruia îi este transmis nu afectează structura apelată ca parametru.
Tipul argumentului trebuie să corespundă tipului parametralui.
#include<stdio.h>
struct alfa{ int x,y;
char ch;
float z; };

13
 void f (struct alfa beta);
void main(void){
struct alfa gama;
gama.x=123;
gama.y=456;
f(gama);
printf („valoarea campului lui x dupa apelul functiei %d”, gama.x);
}
void f(struct alfa beta){
beta.x=beta.x+beta.y;
printf („valoarea campului x dupa asignare=%d”, beta.x);
Dacă declaraţi parametrii de tip structură, trebuie să declaraţi structuri de
tip global, astfel ca toate funcţiile programului să le poată folosi.
Funcţiile pot returna o structură.
#include<stdio.h>
struct alfa { int x; float y; } beta;
struct alfa f(void);
void main(void){
beta = f();
printf ("%d %f", beta . x, beta . y);
}
struct alfa f(void){ stuct alfa temp;
temp.x = 123;
temp.y = -65.345;
return temp;
}

 Atribuiri de structuri de acelaşi tip

Dacă avem declarate două variabile de un acelaşi tip de structură putem să
atribuim uneia valoarea celeilalte. "Valoare" semnifică aici valorile individuale
ale câmpurilor structurii. Dacă structurile ar fi de tipuri diferite nu ar exista
compatibilitate între tipurile câmpurilor, câmpurile uneia neputând conţine
valorile de câmp ale celeilalte.
Atribuirea structurilor poate fi utilă în situaţia în care se doreşte copierea
unui vector în altul în mod direct, şi nu printr-un ciclu (în care se face copierea
succesivă, element cu element).

Sintaxă:
tipStruct var1, var2 ;
var1 = var2 ;

14
 Bineînţeles că se presupune că tipStructură este anterior definit - cu sau
fără typedef.

Exemplu:
struct Oarecare{
char vector[30] ;
} var1, var2 = {"Un sir de caractere"} ;
var1 = var2 ; /*atribuirea propriu-zisă.*/
printf("\n Prima structura are campul egal cu: %s", var1.vector) ;
printf("\n A doua structura are campul egal cu: %s", var2.vector) ;

Dacă rulaţi acest exemplu veţi constata cum compilatorul a copiat

conţinutul unui vector în celălalt.

 Structurile ca tip de argumente sau tip întors de

funcţii
O funcţie poate prelua şi întoarce variabile de tip structură, ca şi pointeri la
tipul structurii.

Funcţii ce preiau structuri

Sintaxă:
tipReturnat numeFunctie(struct numeStruct) ;
sau
tipReturnat numeFunctie(tipStruct) ;

Am declarat - prin prototip - aici o funcţie ce preia un argument de tipul

struct numeStruct. În primul exemplu tipul structurii nu este definit folosind
typedef. În varianta a doua tipul structurii a fost anterior definit folosind typedef.

Exemplu:
typedef struct{
char adresa[100] ;
int sector ;
} ADRESA ;
void fct(ADRESA) ;
...
ADRESA mea = {"Str. Strazilor, nr. 2", 3} ;
fct(mea) ;

15
 Se defineşte mai întâi tipul structurii, după care în prototipul funcţiei se
specifică tipul argumentului ce va fi preluat Undeva în funcţia main() se declară o
variabilă de tipul structurii, iniţializată, iar această variabilă este preluată de
funcţie, în apelul său. Pe post de argument de apel este bineînţeles copia structurii
declarate, ce are rolul de a iniţializa argumentul funcţiei, pentru lucrul în interiorul
acesteia. Apelul este prin valoare.

Funcţii ce intorc structuri

Prototipul unei funcţii ce întoarce un tip structură este:
struct numeStructura numeFct(listaArgumente) ;
sau
tipStructura numeFct(listaArgumente) ;

Exemplu:
struct adresa{
BYTE casaSauBloc ;
char nume[100] ;
int sector ;
};
struct adresa calcule(struct adresa *) ;
...
struct adresa adr1 = { True, "Str. 5", 2}, adr2 ;
adr2 = calcule(&adresa) ;
printf("\n Câmpurile structurii preluate sunt acum: %i, %s, %d.",\n
adr2.casaSauBloc, adr2.nume, adr2.sector) ;

Funcţia declarată preia un pointer la o variabilă de tipul “struct adresa”,

prelucrează valorile câmpurilor acelei structuri şi întoarce variabila modificată
într-o structură de acelaşi tip cu cea preluată. Apoi se afişează noile câmpuri ale
variabilei. Deoarece avem aici preluată o adresă, modificările în interiorul funcţiei
asupra câmpurilor structurii preluate se pot face numai indirect, prin intermediul
pointerului, dar direct la adresa din memorie unde se află structura respectivă.
Aceste modificări sunt valabile şi după încheierea execuţiei funcţiei. Apelul este
prin referinţă.

16
 Bibliografie

http://www.math.uaic.ro
http://www.cs.ucv.ro
http://www.ereferat.md

17
18