Cap 8 1 2021

Capitolul 8
TIPUL STRUCTURĂ - struct

 Declarare
 Operaţii cu structuri
 Iniţializarea structurilor
 Tablouri de structuri si structuri care conţin tablouri
 Structuri ierarhizate
 Relatia pointeri – structuri
 Forme particulare de structuri
Daniela Saru - "Programarea calculatoarelor. Note de curs” – Ed. Printech, 2011 / slides rev. 2021 120
8.1. Declarare
Tipul structură - o colecţie de unul sau mai multe

elemente („membri” sau „câmpuri”) ce pot fi de tipuri
diferite , grupate sub un singur nume.
Fiecare membru al structurii are asociat câte un nume.
Pentru declararea (definirea) unui tip structură se

foloseşte cuvântul cheie struct.
Câmpurile componente se scriu între acolade,

asemănător declarării variabilelor.
Ex.
struct data struct data
{ int zi; ambele forme {int zi, luna, an;};
int luna; descriu tipul de date
int an; numit struct data
};
struct data astazi; declararea variabilei numite astazi, de tipul struct data
Ex.
struct clx
{ float re; definire tip structură + declarare a 2 variabile (z1 şi z2)
float im;
} z1, z2;
Ex.
struct numele structurii poate lipsi dacă definirea se face
{ float re; odată cu declararea variabilelor (Acest stil nu se
float im; recomandă!)
} z1, z2;
Ex.
struct clx { float re; float im;}; /* definire tip */
typedef struct clx NR_CLX;

/*
- se asociază tipului struct complex un nou nume, NR_CLX, stabilit de
către programator, pentru a simplifica scrierea ulterioară a declaraţiilor
de variabile;
- prin convenţie, pentru noul nume se utilizează majuscule, la fel ca şi în
cazul constantelor definite de către utilizator
*/
NR_CLX z1, z2; /*utilizarea noului nume pentru declararea a 2 variabile
Ex.
/*o altă variantă de definire a unui nume nou pentru un tip structură*/
typedef struct { float re; float im;} NR_CLX;
NR_CLX z1, z2;
Obs.
- Forma generală de utilizare a cuvântului cheie typedef este:
typedef Definire_Tip NumeNou;
- Câteva exemple de utilizare a acestei facilităţi pentru alte tipuri de date decât tipul
structură:
typedef unsigned char BYTE;
BYTE m,n; /* 2 variabile de tip unsigned char */
typedef int TABLOU7 [7];

TABLOU7 a,b,c; /* 3 variabile de tip tablou cu 7 elemente de tip int*/
Tipul structură: reuneşte sub un singur nume componente de tip simplu şi/sau
structurat ce pot fi folosite individual sau ca grup (global).
Ex.
struct data astăzi, mâine, data_scrisoare;
astăzi.zi = 23;
astăzi.luna = 11; lucru pe componente;
astăzi.an = 2021;
mâine.zi = astăzi.zi + 1;
data_scrisoare = astazi;
atribuire de structuri (lucru la nivel global), prin copiere bit

cu bit a elementelor corespunzătoare celor 2 structuri (care trebuie să
fie de acelaşi tip!).
Spaţiul de memorie alocat celor trei variabile din exemplul anterior va arăta astfel:
zi zi zi
23 24 23
astăzi luna mâine luna data_scrisoare luna
11 11
an 2021 an an 2021
8.2 Operaţii cu structuri
 atribuire (în întregime sau pe componente);

 acces la membrii structurii (direct sau prin pointeri);
 luarea adresei (întregii structuri sau a membrilor săi);
 transmiterea la funcţii ca parametru:
- a unei structuri (în întregime), prin valoare (copie) – se face copiere bit cu bit;
- a unei structuri (în întregime), prin referinţă (adresă, pointer);
- a unui membru al structurii, prin valoare sau prin referinţă;
 returnarea din funcţii ca rezultat:
- a unei structuri (în întregime); aceasta reprezintă o excepţie de la regula
ce impune funcţiilor să transmită ca rezultat un tip simplu (tipul structură nu
este tip simplu)! – se face copiere bit cu bit;
- a adresei unei structuri (valoare de tip pointer);
- a unui membru al structurii ce poate fi de tip simplu sau structură;
- a adresei unui membru al structurii.
OBS: două structuri nu se pot compara global. Pentru a realiza această operaţie
este necesară scrierea instrucţiunilor care compară explicit componentele
corespondente ale celor două structuri:
Ex. struct data azi, mâine;

............
if (azi.zi == mâine.zi && azi.luna == mâine.luna && azi.an == mâine.an)
printf(”Cele două structuri sunt identice”);
Exemple didactice….
Ex: NR_CLX rezultat (float x, float y) /*NR_CLX definit anterior cu typedef*/
{ NR_CLX z;
z.re = x;
z.im = y;
return z;
}
float real(NR_CLX z)
{ return z.re;}
float imaginar(NR_CLX z)
{return z.im;}
Apelare: NR_CLX a, z1, z2;

……….
a = rezultat (1.2, 3.7);
z2.re = real (z1); => z2 devine complex conjugatul lui z1
z2.im = - imaginar (z1);
OBS. Atunci când se lucrează cu funcţii, se preferă de multe ori transmiterea ca parametru a
unui pointer la structură. Notaţiile utilizate pentru utilizarea componentelor structurii, în acest caz,
sunt similare celor prezentate în exemplul următor.
Ex. NR_CLX z, *p; /* z este o variabilă de tip structură;

p este o variabilă pointer la tip structură */
p = &z; /* se iniţializează valoarea lui p */
/*Notaţiile ce pot fi folosite au următoarele semnificaţii”:*/
(*p) => este chiar structura z

(*p).NumeMembru => este un membru al structurii (una dintre componente)
p -> NumeMembru => este un membru al structurii (una dintre componente);
se foloseşte ca notaţie simplificată, echivalentă ca
semnificaţie cu cea anterioară
Ex: void conjugare(NR_CLX *p)

{ p->im = -p->im; }
Apelare: NR_CLX z;
………….
conjugare(&z); /*valoarea lui z va fi modificată */
OBS. Exemplul anterior ilustrează şi un alt aspect al folosirii pointerilor la structură:

posibilitatea modificării valorii parametrilor formali de tip structură.
/*Pe baza datei calendaristice curente, programul următor calculează şi afişează pe
ecran data zilei de mâine, folosind câte 2 cifre pentru zi, lună şi an.*/
struct data
{ int zi;
int luna;
int an;
}; /*definirea tipului structură ce va fi folosit în întreg programul*/
int nr_de_zile (struct data d); /*calculează numărul de zile din lună/*
int este_an_bisect (struct data d); /*verifică dacă anul este sau nu bisect*/
void main(void)
{ struct data azi, maine;
printf(“Tastaţi data curentă (zz ll aaaa):”);

scanf(“%d%d%d”, &azi.zi, &azi.luna, &azi.an);
maine=azi; /*iniţializare, pentru creşterea vitezei de execuţie a programului*/

if (azi.zi != nr_de_zile (azi))
maine.zi = azi.zi + 1;
else if (azi.luna == 12) /* sfârsit de an*/
{ maine.zi = 1;
maine.luna = 1;
maine.an ++;
}
else /*sfârsit de lună*/
{ maine.zi = 1;
maine.luna ++;
}
printf(“Data de mâine este %d/%d/%d.\n”, maine.luna, maine.zi,
maine.an%100);
}
/*funcţia care calculează numărul de zile din lună*/
int nr_de_zile (struct data d)
{ int zile_în_lună [12] = {31,28,31,30,31,30,31,31,30,31,30,31};
if (este_an_bisect(d) && d.luna == 2)
return 29; /*nr. de zile din luna februarie a unui an bisect*/
else
return zile_în_lună [d.luna – 1];
}
/*funcţia care verifică dacă anul este bisect*/

int este_an_bisect(struct data d)
{ if ((d.an%4 == 0 && d.an%100 != 0) || (d.an%400 == 0) )
return 1; /*este an bisect*/
else
return 0; /*nu este an bisect*/
}
8.3 Iniţializarea structurilor
Asemănătoare, din multe puncte de vedere, cu cea a celor de tip tablou.
De exemplu, declararea cu iniţializare a unei variabile de tip struct data (definit

anterior) se poate scrie astfel:
struct data azi = {30, 11, 2010};
DAR...
... Componentele pentru care nu se specifică valori iniţiale rămân nedefinite, nu se

iniţializează automat cu valoarea 0 (zero), ca în cazul tipului tablou.
De exemplu:
struct data azi = {30, 11}; /*echivalent cu: azi.zi = 30; azi.luna = 11;
azi.an ramane neiniţializat – valoare nedefinită*/
8.4 Tablouri de structuri şi structuri care conţin tablouri
Exemplu (declarare):
void afiseaza (struct data x); /*prototip de funcţie*/
...
struct data aniversare [15]; / *tablou cu 15 elemente de tip struct data */
...
aniversare [1].zi = 30;
aniversare [1].luna = 4;
aniversare [1].an = 2003; /*s-au dat valori elementului aniversare[1]*/
afiseaza(aniversare [1]); /*se foloseşte elementul de tip structură al
tabloului ca parametru al funcţiei*/
Exemplu (iniţializare):
struct data aniversare [3] = {{30,4,2003},{15,6,2000},{3,2,2007}};
=>
.zi 30
aniversare[0] .luna 4
.an
2003
.zi 15
aniversare[1] .luna
6
.an
2000
.zi
aniversare[2] .luna 3
.an 2
2007
8.5 Structuri ierarhizate
Un tip structură care conţine componente de tip structură se mai numeşte şi
„structură ierarhizată”.
Exemplu: moment de tip caracterizat prin oră, minut, secundă, dar şi data
calendaristică asociată (zi, lună, an):
data_si_timp
data timp
zi luna an ora minute secunde
struct data { int zi, luna, an; }; /*definire de tip structură*/
struct timp { int ora, minute, secunde; }; /*definire de tip structură*/
struct data_si_timp
{ struct data primul;
struct timp al_doilea;
} eveniment; /*definire de variabilă*/
struct data_si_timp examen={ {2, 2, 2010} , {9, 0, 0} }; /*declarare cu iniţializare*/
/*eveniment.primul => un membru al structurii numite eveniment*/
eveniment.primul.luna=10; /*membru al structurii primul*/
++eveniment.al_doilea.secunde; /*membru al structurii al_doilea*/
OBS. La fel ca şi valorile de tip structură obişnuite, structurile ierarhizate pot fi

folosite ca elemente componente ale tablourilor. De exemplu:
struct data_si_timp evenimente[100];
evenimente[0].al_doilea.ora = 12; Alte exemple:
evenimente[0]. al_doilea.minute = 0; INM_modif.c --- Joc
evenimente[0]. al_doilea.secunde = 0; Tablou_structuri_15.c
Struct_PRez_2_OK_15.c
8.7 Forme particulare de structuri
Uniunea
Structura cu variante
Câmpul de biţi
8.7.1 Uniunea
Uniunea = o formă particulară de structură, în care câmpurile

componente sunt suprapuse, astfel încât ele să ocupe acelaşi
spaţiu de memorie.
Se pot memora astfel, tipuri diferite de date în acelaşi spaţiu

de memorie, la momente de timp diferite.
union Nume
{ long i; Variabila exemplu nu va putea conţine, simultan, 2 valori
float f; distincte (pentru câmpurile i şi f), ci va conţine o singură
} exemplu; valoare (fie pentru câmpul i, fie pentru câmpul f)
Spaţiul necesar alocării unei variabile de tip union este determinat pe baza
informaţiilor specificate la declarare. În exemplul anterior, daca long int si float sunt
reprezentate pe câte 4 octeţi, reprezentarea internă a uniunii arată astfel:
2000 2001 2002 2003
i sau f
Valoarea care va fi scrisă în acest spaţiu de memorie depinde de câmpul uniunii pe

care îl folosim. De exemplu:
exemplu.i = 1; /*atribuirea unei valori de tip întreg*/

exemplu.f = 0.0; /*înscrierea unei valori de tip real în acelaşi spaţiu de memorie,
peste valoarea înscrisă anterior
Dimensiunea uniunii este suficient de mare pentru a putea cuprinde cel mai mare
câmp, dar nu este neapărat egală cu dimensiunea acestuia, ci poate fi mai mare
sau egală.
Cei interesaţi pot găsi detalii suplimentare despre acest subiect în bibliografia sau
Webografia de specialitate.
Tipul struct poate sa apară în tipul union şi reciproc. Oricare combinaţie poate să
apară în tipul tablou.
union AltNume ocupă spaţiu >= cu dimensiunea celui
{ struct mai „voluminos” câmp component
{ char c1, c2; } s; 2000 2001 2002 2003
long i;
float f;
} ceva; s, i sau f
ceva.s.c1 = ‘a’; /*se atribuie valori primului câmp al variabilei uniune*/

ceva.s.c2 = ‘b’;
Dacă folosim următoarea declaraţie:
union Geaman
{ char c[2];
long i;
float f;
} altceva;
obţinem aceeaşi reprezentare internă ca şi pentru variabila numită ceva, dar putem
atribui valori astfel:
altceva.c[0] = ‘a’;
altceva.c[1] = ‘b’;
Declarare: în cazul uniunilor se folosesc aceleaşi reguli sintactice ca pentru structuri.
Iniţializare:
 în cazul uniunilor numai primul membru se poate iniţializa cu o expresie
constantă (între acolade).
 O variabilă automatică uniune se poate iniţializa cu o altă variabilă automatică
de acelaşi tip.
 Pentru a accesa componentele unei uniuni se foloseşte operatorul punct (.)
sau săgeată (->), dacă se utilizează pointeri.
Exemplu preluat din volumul „Iniţiere în limbajul de programare C” - Dorin Irimescu,
Litografia UPB, 1992
O utilizare importantă a uniunilor este posibilitatea de interpretare diferită a

conţinutului, cu ajutorul câmpurilor componente.
Următorul exemplu schiţează o problemă de transfer de informaţii.
Să presupunem că valorile ce urmează a fi transmise sunt de tip real, dublă precizie.
Transmisia se poate face însă numai serial (octet după octet), astfel încât informaţiile
trebuie recompactate după recepţionare.
În acest scop, se poate defini un tip union care să permită interpretarea grupului de
octeţi recepţionaţi (de exemplu, 8 octeţi) ca o unică valoare de tip real – dublă precizie.
Funcţia descrisă în fragmentul de program următor reconstruieşte o valoare de tip

dublă precizie (8 octeţi) din valorile de tip char (1 octet) furnizate de către altă funcţie -
citeste_octet () – care se presupune că lucrează cu echipamentul transmiţător.
/*interpretarea diferita a datelor intr-o uniune*/
char citeste_octet (void); /*prototipul unei functii pe care nu o vom detalia aici*/
union val_dubla_prec
{ char c[8];
double val;
}; /*definirea tipului union*/
double citeste_val_dubla_prec (void )

{ int k;
union val_dubla_prec d;
for( k=0; k<8; k++)
d.c[k] = citeste_octet();
return d.val;
}
8.7.2 Structura cu variante
Presupunem că dorim să scriem un program care să ţină evidenţa persoanelor ce
urmează să se prezinte la interviu în vederea angajării la o firmă. Firma oferă posturi
extrem de diverse, atât pentru persoane calificate cât şi pentru persoane necalificate.
Din acest motiv, un minimum de informaţii despre candidaţi ar putea fi structurat
astfel:
- nume şi prenume;
- data naşterii;
- sex;
- studii:
- şcoală generală – caz în care nu se mai cer alte informaţii;
- liceu sau şcoală profesională – se cere media de absolvire;
- facultate – se cer informaţii despre:
- numele facultăţii;
- media de absolvire;
- master;
- cursuri postuniversitare.
Este evident că dacă am crea un tip structură cu caracter general care să cuprindă
câte un câmp pentru fiecare dintre informaţiile menţionate s-ar irosi mult spaţiu de
memorie deoarece, de exemplu, în cazul unui candidat care a absolvit doar şcoala
generală rămân nefolosite toate câmpurile asociate liceului şi facultăţii.
O rezolvare convenabilă a acestei probleme este:
 definirea câmpului „studii” ca fiind de tip union
 adăugarea unui câmp suplimentar numit, de exemplu, „tip_studii” care să
ia valorile întregi 1, 2 sau 3, pentru a preciza că în câmpul „studii” vom stoca
informaţii despre „şcoală generală”, „liceu sau şcoală profesională” sau
„facultate”.
Observaţie importantă:
Câmpul suplimentar, numit şi câmp discriminator, are rolul de a preciza

semnificaţia valorii uniune folosite în program şi apare, de obicei, în orice aplicaţie
software în care se utilizează tipul union.
Exemplu tipic de utilizare a unei uniuni:
/* în câmpul discriminator, de tip caracter, numit tip, vom pune valoarea:
‘C’ – dacă în câmpul uniune dorim să memorăm o valoare de tip char;
‘I’ – dacă în câmpul uniune dorim să memorăm o valoare de tip int;
‘F’ – dacă în câmpul uniune dorim să memorăm o valoare de tip float.
Funcţia ce afişează conţinutul câmpului uniune va interpreta ca “eroare” orice altă
valoare caracter găsită în câmpul discriminator*/
#include <stdio.h>
#define CARACTER ‘C’
#define INTREG ‘I’
#define REAL ‘F’
struct exemplu
{ char tip; /*câmpul discriminator, de tip caracter, numit tip*/
union informatie
{ char c;
int i;
float f;
}valoare; /*câmpul de tip uniune, numit valoare*/
}; /*s-a încheiat definirea tipului structură*/
void afisare(struct exemplu d)
{ printf("\n Valoarea este...");
switch ( d.tip )
{ case CARACTER: printf("%c", d.valoare.c); break;
case INTREG: printf("%d", d.valoare.i); break;
case REAL: printf("%f", d.valoare.f); break;
default: printf("tip necunoscut: %c\n",d.tip);
}
}
void main(void)
{ struct exemplu a;
a.tip = CARACTER; /*vrem ca semnificatia câmpului uniune sa fie “caracter”*/
a.valoare.c = ‘B’; /*stocăm informaţia în câmpul uniune*/
afisare(a);
a.tip = REAL; /*vrem ca semnificatia câmpului uniune să fie “val. reală”*/
a.valoare.f = (float) 12.34; /*stocăm informaţia în câmpul uniune*/
afisare(a);
a.tip = ‘x’; /*dăm o valoare greşită câmpului uniune*/
a.valoare.i = 111; /*încercăm să stocăm o informaţie în câmpul uniune*/
afisare( a ); /*va genera mesajul de “eroare”…*/
}
Pe ecran:
Valoarea este...B
Valoarea este...12.34
Valoarea este...tip necunoscut: x
8.7.3 Câmpul de biţi
În limbajul C, cel mai „mic” tip este tipul char, reprezentat intern pe 1 octet (8 biţi).
În variabile de tip struct sunt necesare uneori şi de câmpuri cu lungime mai mică de 1
octet (câmpuri ale căror valori sunt întotdeauna mai mici decât 255!).
De aceea, limbajul C permite ca în cadrul unei structuri să se specifice numărul de

cifre binare (biţi) pe care se va reprezenta intern un anumit câmp.
Singura restricţie impusă în acest caz este că valorile câmpului pot fi numai de tip
int sau char.
Ex: struct ex
{ unsigned a:1;
unsigned b:3;
unsigned :4;
unsigned c:3;
unsigned d:2;
} exemplu;
Presupunând, pentru simplificarea prezentării, că lucrăm cu un compilator ce reprezintă

tipul int pe 2 octeţi (16 biţi), câmpurile de biţi din variabila exemplu pot avea următoarea
dispunere în memoria internă:
2 octeţi (16 biţi)
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
d c biţi nefolosiţi b a
câmpul fără nume
După cum se poate observa, câmpurile de biţi permit folosirea judicioasă a spaţiului de
memorie în funcţie de domeniul de valori pe care îl acoperă:
Câmp Valori
exemplu.a 0.....1
exemplu.b 0.....7
exemplu.c 0.....7
exemplu.d 0.....3
Câmpurile de biţi sunt “împachetate” în unităţi de memorare care au dimensiune
egală cu a tipului int (2 octeţi, în cazul nostru). Dacă numărul de octeţi pe care se
reprezintă tipul int este de 4, unitatea de memorare va ocupa 4 octeţi!
Lungimea fiecărui câmp de biţi va fi, în general, mai mică sau cel mult egală cu cea a
unităţii de memorare.
Câmpurile fără nume pot fi folosite pentru alinierea (plasarea) următorului câmp de
biţi la începutul octetului următor.
Dacă un câmp fără nume are lungime 0 (zero), următorul câmp de biţi se aliniază la
adresa de început a următoarei unităţi de memorare.
Utilitate:
- Permit folosirea eficientă a spaţiului de memorie;
- Permit folosirea unor structuri de date de formă impusă;
- Permit încadrarea într-o formă de reprezentare internă impusă;
- Simplifică lucrul la nivel de bit, dar codul generat este voluminos;
Reprezentarea internă a unei structuri cu câmpuri de biţi este dependentă de

implementare, ceea ce poate genera probleme legate de portabilitatea programelor.
Dependenţa de implementare se referă în acest caz mai ales la:

- ordinea în care se face alocarea spaţiului din unitatea de memorare (de la
dreapta la stânga sau de la stânga la dreapta);
- dimensiunea unităţii de memorare
Exemplu de utilizare (didactic)
Structura definită în exemplul anterior (struct ex) poate permite afişarea anumitor
grupuri de biţi din reprezentarea internă a unui întreg (16 biţi):
union test
{ struct ex cifre; Cp_biti.C
unsigned short w;
} u;
unsigned short x;
printf(“Tastaţi valoarea lui x:”);
scanf(“%hu”,&x);
u.w = x;
printf(“Valorile câmpurilor din reprezentarea internă a lui x, conforme tipului
struct ex, sunt:\n”);
printf(“d=%u c=%u b=%u a=%u\n”, u.cifre.d, u.cifre.c, u.cifre.b, u.cifre.a);
OBS: exemplul oferă o metodă de evidenţiere a conţinutului la nivel de bit ce poate fi

folosită ca alternativă la metoda de “filtrare” a biţilor prin “mascări” cu operatori logici
şi de deplasare la nivel de bit (prezentată într-un capitol anterior).
Un exemplu practic de utilizare a câmpurilor de biţi dar şi a operatorilor la
nivel de bit este descris în articolul intitulat „How to Program an 8-bit
Microcontroller Using C language” – Richard Mann, Imagecraft
http://ww1.microchip.com/downloads/en/DeviceDoc/avr_3_04.pdf

Cap 8 1 2021

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Cap 8 1 2021

Încărcat de

Drepturi de autor:

Formate disponibile

Capitolul 8

TIPUL STRUCTURĂ - struct

Tipul structură - o colecţie de unul sau mai multe

Fiecare membru al structurii are asociat câte un nume.

Pentru declararea (definirea) unui tip structură se

Câmpurile componente se scriu între acolade,

typedef struct clx NR_CLX;

NR_CLX z1, z2; /*utilizarea noului nume pentru declararea a 2 variabile

typedef int TABLOU7 [7];

atribuire de structuri (lucru la nivel global), prin copiere bit

 atribuire (în întregime sau pe componente);

Ex. struct data azi, mâine;

Apelare: NR_CLX a, z1, z2;

Ex. NR_CLX z, *p; /* z este o variabilă de tip structură;

/*Notaţiile ce pot fi folosite au următoarele semnificaţii”:*/

(*p) => este chiar structura z

Ex: void conjugare(NR_CLX *p)

OBS. Exemplul anterior ilustrează şi un alt aspect al folosirii pointerilor la structură:

printf(“Tastaţi data curentă (zz ll aaaa):”);

maine=azi; /*iniţializare, pentru creşterea vitezei de execuţie a programului*/

/*funcţia care verifică dacă anul este bisect*/

Asemănătoare, din multe puncte de vedere, cu cea a celor de tip tablou.

De exemplu, declararea cu iniţializare a unei variabile de tip struct data (definit

... Componentele pentru care nu se specifică valori iniţiale rămân nedefinite, nu se

zi luna an ora minute secunde

OBS. La fel ca şi valorile de tip structură obişnuite, structurile ierarhizate pot fi

Uniunea = o formă particulară de structură, în care câmpurile

Se pot memora astfel, tipuri diferite de date în acelaşi spaţiu

2000 2001 2002 2003

Valoarea care va fi scrisă în acest spaţiu de memorie depinde de câmpul uniunii pe

exemplu.i = 1; /*atribuirea unei valori de tip întreg*/

ceva.s.c1 = ‘a’; /*se atribuie valori primului câmp al variabilei uniune*/

O utilizare importantă a uniunilor este posibilitatea de interpretare diferită a

Următorul exemplu schiţează o problemă de transfer de informaţii.

Să presupunem că valorile ce urmează a fi transmise sunt de tip real, dublă precizie.

Funcţia descrisă în fragmentul de program următor reconstruieşte o valoare de tip

double citeste_val_dubla_prec (void )

Câmpul suplimentar, numit şi câmp discriminator, are rolul de a preciza

De aceea, limbajul C permite ca în cadrul unei structuri să se specifice numărul de

Presupunând, pentru simplificarea prezentării, că lucrăm cu un compilator ce reprezintă

2 octeţi (16 biţi)

Reprezentarea internă a unei structuri cu câmpuri de biţi este dependentă de

Dependenţa de implementare se referă în acest caz mai ales la:

OBS: exemplul oferă o metodă de evidenţiere a conţinutului la nivel de bit ce poate fi

S-ar putea să vă placă și

Ex. NR_CLX z, p; / z este o variabilă de tip structură;

/Notaţiile ce pot fi folosite au următoarele semnificaţii”:/

maine=azi; /iniţializare, pentru creşterea vitezei de execuţie a programului/

/funcţia care verifică dacă anul este bisect/

exemplu.i = 1; /atribuirea unei valori de tip întreg/

ceva.s.c1 = ‘a’; /se atribuie valori primului câmp al variabilei uniune/