CURS NR.

10

FUNCŢII DE BIBLIOTECĂ MATEMATICĂ

DIRECTIVE PREPROCESOR
MACROINSTRUCŢIUNI

10.1. Funcţii de bibliotecă matematică

Compilatorul limbajului C este însoţit de o bibliotecă de funcţii grupate după acţiunea lor. Scopul
acestei biblioteci de funcţii este acela de a uşura munca programatorului, acesta putând apela funcţiile de
bibliotecă pentru a rezolva o problemă.
Funcţiile de bibliotecă matematică sunt acelea care rezolvă anumite probleme matematice şi ele
au prototipurile în fişierul antet math.h, acesta va trebui să fie inclus la începutul programului sursă în
care se apelează aceste funcţii.

Prototip Forma de apel Semnificaţia matematică

double sin(double x); sin(x); Sinus
double cos(double x); cos(x); Cosinus
double tan(double x); tan(x) Tangenta
double asin(double x); asin(x); Arcsinus
double acos(double x); acos(x); Arccosinus
double atan(double x); atan(x) Arctangentă
double sinh(double x); sinh(x); Sinus hiperbolic
double cosh(double x); cosh(x); Cosinus hiperbolic
double tanh(double x); tanh(x); Tangenta hiperbolică
double exp(double x); exp(x); ex
double log(double x); log(x); ln(x)
double log10(double x); log10(x); lg(x)
double sqrt(double x); sqrt(x); x
y
double pow(double x, double y); pow(x, y); x
double pow10(double x); pow10(x); 10x
double ceil(double x); ceil(x); Calculează cel mai mic întreg
mai mare sau egal cu x
double floor(double x); floor(x); Calculează cel mai mare întreg
mai mic sau egal cu x
double fabs(double x); fabs(x); Valoarea absolută a lui x
double cabs(struct complex z); cabs(z); Valoarea absoluta a unui număr
complex
double atan2(double y, double x); atan2(y, x); y
arctg
x
double poly(double x, int n, poly( x, n, c); Calculează valoarea în x a
double c[]); polinomului de gradul n cu
coeficienţi daţi de elementele
tabloului c astfel: c[0] –
coeficientul termenului liber,
c[1] – coeficientul lui x1, …,
c[n] coeficientul lui xn.

La apelul funcţiilor de bibliotecă matematice trebuie să se ţină cont de domeniile de definiţie ale
acestor funcţii stabilite în matematică, altfel vor apărea erori.

Exemplu: funcţia sqrt trebuie să aibă argumentul pozitiv (≥ 0).

La funcţiile trigonometrice, argumentele trebuie date în radiani (nu în grade).

1
 10.2. Directive preprocesor
Directivele preprocesor sunt instrucţiuni care se execută înaintea compilării unui program. Ele
constau în general în substituţii cu ajutorul cărora pot fi realizate următoarele acţiuni:
- includeri de fişiere antet sau de fişiere sursă ale utilizatorilor;
- definiţii şi apeluri de macroinstrucţiuni;
- compilare condiţionată.
Directivele preprocesor se recunosc datorită caracterului diez (#) cu care încep. Ele pot fi plasate
oriunde în program însă în general se plasează la începutul programului deoarece acţiunea lor are loc din
poziţia în care sunt scrise.
Observaţie: după o diectivă preprocesor nu se pune niciodată caracterul ;
Cele mai utilizate directive preprocesor sunt: #include şi #define
Directiva #include
Are două forme de utilizare:
a) #include<nume_fişier.h>
b) #include”[cale]nume_fişier_utilizator.cpp”
Forma a) se foloseşte pentru includerea în fişierul sursă a unor fişiere antet (header) care conţin
prototipuri şi definiţii ale funcţiilor de bibliotecă şi ale constantelor simbolice care vor fi folosite în
program. Parantezele unghiulare (< >) între care se scrie numele fişierului antet indică compilatorului că
acesta se găseşte într-un director special şi anume în subdirectorul INCLUDE din directorul unde este
instalat mediul de programare.
Forma b) se foloseşte pentru ainclude în programul sursă fişiere sursă ale utilizatorului.
[cale] – este opţională, cu ajutorul ei se indică calea de la directorul rădăcină pe care se găseşte fişierul
care trebuie inclus în program. Fişierul respectiv poate avea orice extensie, nu este obligatoriu să aibă
extensia cpp. În vazul în care nu este specificată calea, fişierul antet va fi căutat în directorul curent.
Exemple:
#include “functii.cpp”
#include “c:\\ limb_c \\ laborat \\ soarec.h”
Observaţie: este permisă includerea unui fişier text care la rândul său conţine includeri de alte
fişiere text.
Directiva #define
Cea mai simplă utilizare a directivei #define este cea pentru definirea constantelor simbolice.
Exemplu: #define PI 3.14159
Poate fi plasată oriunde în program, acţionând de la linia în care apare până la sfârşitul
programului sau până la întâlnirea unei directive #undef
Efectul directivei preprocesor #define constă în înlocuirea la preprocesare a numelui constantei
simbolice cu valoarea acesteia.

Exemplul nr. 1:

#define M 6 La compilare:
#define N 5 main()
main() { int sir1[6];
{ int sir1[M]; int sir2[5];
int sir2[N]; int mat[6][5];
float mat[M][N]; …

2
 Deoarece la preprocesare se fac înlocuiri nu şi calcule este indicat ca succesiunea de caractere cu
care se face înlocuirea numelui să fie cuprinsă între paranteze rotunde.
Exemplul nr. 2:

#define A 2
…
main()
{ int x;
x=4+A
…
#undef A
float z;
#define A 3.67
z = 7 – A;
…

Prin utilizarea directivei #undef A îşi pierde valoarea atribuită anterior. În urma rulării
programului vom avea următoarele valori: x = 6 şi z = 3.33.

10.3. Macroinstrucţiuni (macrouri)

Pentru definirea unei macroinstrucţiuni se foloseşte tot directiva preprocesor #define, forma
generală fiind:
#define NUME(pf1, pf2, … , pfn) succ_de_caractere
Observaţi:
- numele se scrie cu litere mari (dar nu este însă obligatoriu);
- între numele macroinstrucţiunii şi paranteză deschisă ( nu se lasă spaţiu liber;
- pf1, pf2, … , pfn sunt parametrii formali ai macroului, prin intermediul lor se pot face înlocuiri
în program cu succesiuni de caractere diferite, la diferite apeluri ale macroului;
- succesiunea de caractere trebuie să conţină parametri formali şi să efectueze nişte operaţii;
- chiar dacă succesiunea de caractere este un apel de funcţie sau o instrucţiune oarecare, la sfârşit nu
se pune ; ;
- dacă succesiunea de carctere este prea lungă, programatorul poate să o continue pe linia următoare
punând la sfârşitul primei linii caracterul \.
O asemănare între macrouri şi funcţii ar fi aceea că atât macrourile cât şi funcţiile au o definiţie şi
mai multe apeluri. Deosebirea dintre cele două constă în modul de lucru al acestora: la apelul unei funcţii
se înlocuiesc valorile parametrilo formali cu valorile parametrilor efectivi şi se transferă execuţia într-o
zonă de memorie alocată codului executabil al funcţiei, respectiv în cazul apelului unui macrou se
înlocuiesc parametri formali cu cei efectivi de la apel în cadrul succesiunii de caractere şi apoi se
înlocuieşte în program apelul macroului cu succesiunea de caractere corespunzătoare.
Exemplu:

⎧ x − 8 daca x ≥ 1
Calculul valorii funcţiei: y = ⎨ 2
⎩ x + 2 x + 3 daca x < 1
#define F(x) ((x >= 1) ? x-8 : x*x+2*x+3)

În program: La execuţie
… …
for(x=a;x<=b;x+=h) for(x=a;x<=b;x+=h)
{ y = F(x); { y = ((x >= 1) ? x-8 : x*x+2*x+3);
printf(“\n x = %f \t y = %f”,x”y); printf(“\n x = %f \t y = %f”,x”y);
} }
… …

3
 Program exemplu: Se dau catetele unui triunghi dreptunghic. Se cere să se determine: ipotenuza,
unghiurile triunghiului, perimetrul, aria şi înălţimea din A.

Relaţiile utilizate sunt:

- calculul ipotenuzei: a = b 2 + c 2 ;

⎛c⎞
- calculul unghiului C: Cˆ = arcsin⎜ ⎟ ;
⎝a⎠
a b
⎛c⎞
- calculul unghiului B: Bˆ = arccos⎜ ⎟ ;
⎝a⎠
- perimetrul: p = a + b + c ; D ha
b⋅c
- aria triunghiului: s = ;
2
- înălţimea: ha = b ⋅ sin Cˆ
B c A

#include<stdio.h>
#include<conio.h>
#include<math.h>
#define PI 3.14159

void main(void)
{ float a, b, c, ub, uc, p, s, ha; clrscr();

// citirea catetelor
printf("\n Introduceti cateta b:"); scanf("%f",&b);
printf("\n Introduceti cateta c:"); scanf("%f",&c);

// calculul si afisarea valorii ipotenuzei

a=sqrt(b*b+c*c); printf("\n a = %f",a);

// calculul si afisarea valorii unghiului C

uc=asin(c/a); printf("\n uc = %f",uc*180/PI);

// calculul si afisarea valorii unghiului B

ub=acos(c/a); printf("\n ub = %f",ub*180/PI);

// calculul si afisarea valorii perimetrului p

p=a+b+c; printf("\n p = %f",p);

// calculul si afisarea valorii ariei s

s=b*c/2; printf("\n s = %f",s);

// calculul si afisarea valorii inaltimii ha

ha=b*sin(uc); printf("\n ha = %f",ha);

getch();
}