Borland C++

Functii din biblioteca standard

Principalele functii ale limbajului C++

Limbajul C++ pune la dispozitia programatorilor un numar foarte mare de functii care
permit executarea diferitelor operatii de prelucrarea a datelor. Prototipurile acestor functii se
gasesc in diferite fisiere antet, unele dintre ele putandu-se afla chiar in doua sau trei asemneea
fisiere. In continuare vor fi prezentate si exemplificate o parte din aceste functii.

Functii de conversie
Conversia unui sir intr-o valoare numerica
Functiile atof si _atold
Prototipurile acestor functii se gasesc in fisierele antet math.h si stdlib.h. Aceste
functii au urmatoarele utilizari:
 atof – converteste un sir de caractere numerice intr-o valoare reala simpla precizie.
 _atold - converteste un sir de caractere numerice intr-o valoare reala dubla precizie.
Prototipurile functieilor sunt:
double atof(const char *s);
long double _atold(const char *(s));
Observatii:
 functia atof converteste sirul *s la un real in simpla precizie.
 functia _atold converteste sirul *s la un real in dubla precizie.
 functia atof recunoaste caracterele reprezentarii unui numar in virgula mobila format
din urmataorele:
o o succesiune de tab-uri si spatii optionale [ws]
o un semn optional [sign]
o un sir de cifre [ddd] si, optional, simbolul zecimal (.); cifrele pot fi atat in stanga
cat si in dreapta simbolului zecimal
o un caracter e sau E urmat de un intreg cu semn.
Caracterele trebuie sa corespunda urmatoarului format
[whitespace] [sign] [ddd] [.] [ddd] [e|E[sign]ddd]
 Deasemenea functia atof recunoaste urmatoarelr constante
o +INF and -INF (plus si minus infinit)
o +NAN si -NAN (Not-a-Number – nu este un numar)
 In atof, primul caracter nerecunoscut determina terminarea conversiei.
 Functiile strtod si strtoul sunt similare functiilor atof si respectiv _atold; ele
asigura o mai buna detectare a erorilor.si din acest motiv sunt preferate in unele
aplicatii.
Valori returnate:
Daca operatia a decurs normal, functiile returneaza valoarea convertita a sirului de
intrare. In caz ca sirul de intrare nu poate fi convertit, aceste functii returneaza 0. Daca in urma
conversiei se produce o depasire atunci functiile executa urmatoarele:
 returneaza plus sau minus HUGE_VAL
 seteaza errno pe ERANGE
 nu apeleaza matherr sau _matherrl
Exemplu pentru functia atof
#include <stdlib.h>
#include <stdio.h>
int main(void)
{

1
 Borland C++
Functii din biblioteca standard
float f;
char *str = "12345.67";
f = atof(str);
printf("Sirul = %s are valoarea reala = %f\n", str, f);
return 0;
}
va afisa:
Sirul 12345.67 are valoarea reala = 12345.669922
Functia (macrocomanda) atoi
Macrocomanda atoi converteste un sir de caractere numerice intr-o valoarea intreaga.
Prototipul functiei se afla in fisierul antet stdlib.h si are urmatoarea forma:
int atoi(const char *s);
Observatii:
 Functia atoi converteste sirul *s la un tip int.
 Functia atoi recunoaste urmatoarele caractere (in ordinea indicata):
o o succesiune de tab-uri si spatii [ws]
o un semn optional [sn]
o un sir de cifre [ddd]
Caracterele trebuie sa corespunda urmatorului format:
[ws] [sn] [ddd]
 Primul caracter nerecunoscut de functia atoi termina conversia.
 Pentru functia atoi nu este prevazuta depasirea (rezultatele sunt nedefinite).
Valori returnate:
Daca operatia s-a terminat normal, functia returneaza valoarea convertita a sirului de
intrare. Daca sirul nu poate fi convertit, functia returneaza 0.
Exemplu:
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
int n;
char *str = "12345.67";
n = atoi(str);
printf("Sirul %s convertit la intreg este %d\n", str, n);
return 0;
}
va afisa:
Sirul 12345.67 convertit la un intreg este 12345
Functia atol
Functia atol converteste un sir de caractere numerice intr-un intreg lung. Prototipul se
gaseste in fisierul antet stdlib.h si are urmatoare forma:
long atol(const char *s);
Observatii:
 Functia atol converteste sirul *s la un intreg lung. Ea recunoaste caracterele in
urmatoarea ordine:
o o succesiune de tab-uri si spatii [ws]
o optional un semn [sn]
o un sir de cifre [ddd]
Caracterele trebuie sa corespunda urmatorului format:
[ws] [sn] [ddd]
2
 Borland C++
Functii din biblioteca standard
 In atol, intalnirea primului caracter nerecunoscut determina terminarea conversiei.
 Nu este prevazuta situatia de depasire (rezultatele sunt nedefinite)
Valoare returnata:
Daca operatia a decurs normal, functia returneaza valoarea convertita a sirului de
intrare. Daca sirul nu poate fi convertit, functia returneaza 0.
Examplu:
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
long l;
char *lstr = "98765432";
l = atol(lstr);
printf("Sirul %s convertit la intreg este %ld\n", lstr, l);
return(0);
}
va afisa:
Sirul 98765432 convertit la intreg este 98765432
Functiile strtod, _strtold, strtol si strtoul
Aceste functii au prototipurile in fisierul antet stdlib.h si asigura conversia unui sir de
caractere cifrice in valori numerice astfel:
 strtod converteste un sir de cifre intr-un real dubla precizie;
 strtol converteste un sir de cifre intr-un intreg lung;
 _strtod converteste un sir de cifre intr-un real extins;
 strtoul converteste un sir de cifre intr-un intreg lung fara semn.
Prototipurile functiilor sunt urmatoarele:
double strtod(const char *s, char **endptr);
long strtol(const char *s, char **endptr, int radix);
long double _strtold(const char *(s), char **(endptr));
unsigned long strtoul(const char *s, char **endptr, int radix);
Observatii:
 s este un sir de caractere numerice (depinzand de functia careia i se transmite ca
parametru) si care poate fi interpretat ca:
o o valoare reala in dubla precizie (strtod)
o o valoare intreaga lunga (strtol)
o o valoare reala extinsa (_strtold)
o o valoare intreaga fara semn (strtoul)
 Caracterele trebuie sa corespunda urmatoarelor formate generice:
o strtod: [ws] [sn] [ddd] [.] [ddd] [fmt[sn]ddd]
o strtol: [ws] [sn] [0] [x] [ddd]
o _strtold: [ws] [sn] [ddd] [.] [ddd] [fmt[sn]ddd]
o strtoul: [ws] [sn] [0] [x] [ddd]
unde:
 [ws] caractere albe (optional)
 [sn] semnul plus sau minus (optional)
 [ddd] cifre (optional)
 [fmt] caracterul e sau E (optional)
 [.] simbolul zecimal (optional)
 [0] zero (optional)
 [x] caracterul x sau X (optional)

3
 Borland C++
Functii din biblioteca standard
 De asemenea, functia strtod recunoaste constantele +INF si -INF pentru plus si
minus infinit, precum si constantele +NAN si -NAN pentru Not-A-Number.
 Aceste functii opresc citirea sirului la intalnirea primului caracter pe care ele nu-l
recunoasc.
Valori returnate:
Daca operatia s-a terminat normal,
 Functia strtol returneaza valoarea lui s ca un intreg lung;
 Functia strtod returneaza valoarea lui s ca un real in dubla precizie;
 Functia _Strtod returneaza valoarea lui s ca un real extins;
 Functia strtoul returneaza valoarea lui s ca un intreg lung fara semn;
In caz de eroare,
 (in caz de depasire) functia strtod returneaza plus sau minus HUGE_VAL;
 (in caz de depasire) _strtold returneaza plus sau minus _LHUGE_VAL;
 Functiile strtol si strtoul returneaza 0.
Example:
1. Exemplu pentru functia strtod
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char input[80], *endptr;
double value;
printf("Introduceti un numar real in virgula mobila: ");
gets(input);
value = strtod(input, &endptr);
printf("Sirul %s reprezinta numarul %lf\n", input, value);
return 0;
}
daca se va introduce 123.75, se va afisa:
Introduceti un numar real in virgula mobila: 123.75
Sirul 123.75 resprezinta numarul 123.750000
2. Exemplu pentru functia strtol
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
char *string = "87654321", *endptr;
long lnumber;
lnumber = strtol(string, &endptr, 10);
printf("Sirul: %s este numarul: %ld\n", string, lnumber);
return 0;
}
va afisa:
Sirul: 87654321 este numarul: 87654321
3. Exemplu pentru functia strtoul
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
char *string = "87654321", *endptr;
unsigned long lnumber;
lnumber = strtoul(string, &endptr, 10);

4
 Borland C++
Functii din biblioteca standard
printf("sirul: %s e intregul fara semn: %lu\n", string, lnumber);
return 0;
}
va afisa:
Sirul: 87654321 e intregul fara semn: 87654321
Argumentul endptr
Argumentul endptr este folosit in functiile strtol si strtoul. Daca endptr este
null, aceste functii seteaza *endptr (“urmatorul pointer spre caracter”) pentru a referi
caracterul care opreste scanarea (*endptr = &stopper). Argumentul endptr este util la
detectarea erorilor.
Argumentul radix
Argumentul radix este utilizat in functiile strtod, strtol, _strtold si strtoul. In
functiile strtol si strtoul este interpretat:
 o valoare <0 – valoare incorecta
 o valoare 0 – primele caractere ale sirului s determina baza valorii ce va fi convertita
astfel:
Primul caracter Al doilea caracter Sirul s este interpretat ca
0 1-7 Octal
0 x sau X Hexazecimal
1-9 Zecimal
 o valoare 1 – valoare incorecta
 o valoare intre 2 si 36 – intregul este exprimat in baza radix
 o valoare >36 – valoare incorecta.
Observatii:
 Orice valoare incorecta pentru radix determina ca rezultatul sa fie 0 si seteaza
*endptr pe inceputul pointerului spre sir;
 Cand s este interpretat ca octal, orice caracter care nu este intre 0 si 7 nu va fi
recunoscut;
 Cand s este interpretat ca zecimal, orice caracter care nu este intre 0 si 9 nu va fi
recunoscut;
 Cand s este interpretat ca un numar in orice alta baza (2 la 36), vor fi recunoscute
numai numeralele si literele din baza respectiva. Spre exemplu:
radix Recunoaste numeralele si caracterele
5 0--4
20 0--9 and A--J

Conversia numerelor in siruri de caractere

Functia ecvt si fcvt
Pentru conversia unui numar real dubla precizie intr-un sir de caractere se folosesc
functiile ecvt si fcvt. Prototipurile acestor functii se gasesc in fisierul antet stdlib.h si au
urmataoarea forma:
char *ecvt(double value, int ndig, int *dec, int *sign);
char *fcvt(double value, int ndig, int *dec, int *sign);
Observatii:
 Functiile ecvt si fcvt convertesc valoarea numerica value la un un sir de ndig cifre
(sirul este terminat cu caracterul null), incepand cu cifra din stanga cea mai
semnificativa si returneaza un pointer la acest sir.
 Pozitia relativa a simbolului zecimal fata de inceputul sirului este stocat indirect prin
intermediul argumentului dec. Valoare lui dec puterea lui 10 la care trebuie impartit
sau inmultit value astfel ca punctul zecimal sa fie la stanga, iar prima cifra sa fie
5
 Borland C++
Functii din biblioteca standard
diferita de zero. Astfel, daca value este 456.78, atunci dec este 3, iar daca value
este 0.00987, atunci dec este –2.
 In sirul returnat nu exista simbolul zecimal.
 Daca valoarea de convertit este negativa (value < 0), atunci word *sign este diferit
de zero; in caz contrar este zero.
 Functia ecvt rotunjeste cifra de ordin inferior.
 Functia fcvt rotunjeste cifrele corecte la numarul de cifre specificat prin argumentul
ndig.
Valoare returnata:
 ecvt: Refera o data statica pentru sirul de cifre. Continutul acestei date statice
este rescris la fiecare apelare a functiei ecvt.
 fcvt: Refera o data statica pentru sirul de cifre. Continutul acestei date statice
este rescris la fiecare apelare a functiei fcvt.
Exemple:
// Exemplu de utilizare a functiei ecvt
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
char *string;
double value;
int dec, sign;
int ndig = 10;
clrscr();
value = 0.09876;
string = ecvt(value, ndig, &dec, &sign);
printf("%8.3f\tsirul = %s\tpozitia punctului = %d semn = %d\n",
value, string, dec, sign);
value = -123.45; ndig= 15;
string = ecvt(value,ndig,&dec,&sign);
printf("%8.3f\tsirul = %s\tpozitia punctului = %d semn = %d\n",
value, string, dec, sign);
value = 0.6789e5; ndig = 5;
string = ecvt(value,ndig,&dec,&sign);
printf("%8.3f\tsirul = %s/tpozitia punctului = %d semn = %d\n",
value, string, dec, sign);
return 0;
}
La rularea acestui program, pe ecran se va afisa:
0.099 sirul = 9876000000 pozitia punctului = -1 semn = 0
-123.450 sirul = 123450000000000 pozitia punctului = 3 semn = 1
67890.000 sirul = 67890 pozitia punctului = 5 semn = 0
// Exemplu pentru functia fcvt
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
char *str;
double num;
int dec, sign, ndig = 5;
num = 9.876;

6
 Borland C++
Functii din biblioteca standard
str = fcvt(num, ndig, &dec, &sign);
printf("%8.3f\tsirul = %10s pozitia punctului = %d semn = %d\n",
num, str, dec, sign);
num = -123.45;
str = fcvt(num, ndig, &dec, &sign);
printf("%8.3f\tsirul = %10s pozitia punctului = %d semn = %d\n",
num, str, dec, sign);
num = 0.678e5;
str = fcvt(num, ndig, &dec, &sign);
printf("%8.3f\tsirul = %10s pozitia punctului= %d semn = %d\n",
num, str, dec, sign);
return 0;
}
Prin rularea acestui program, pe ecran se va afisa:
9.876 sirul = 987600 pozitia punctului = 1 semn = 0
-123.450 sirul = 12345000 pozitia punctului = 3 semn = 1
67800.000 sirul = 6780000000 pozitia punctului = 5 semn = 0
Functia gcvt
Converteste un numar in virgula mobila intr-un sir. Prototipul functiei se gaseste in
fisierul antet stdlib.h si re urmatorul format:
char *gcvt(double value, int ndec, char *buf);
Observatii:
 Functia gcvt converteste numarul value intr-un sir ASCII terminat cu caracterul null.
Sirul convertit se afla in zona de memorie buf.
 Functia gcvt genereaza ndec cifre semnificative in formatul FORTRAN F, daca este
posibil. In caz contrar returneaza sirul in formatul printf E (pregatit pentru tiparire).
 Functia gcvt suprima zerourile nesemnificative.
Valoare returnata: Daca operatia decurge normal, returneaza adresa sirului *buf.
Exemplu:
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
char str[25];
double num;
int sig = 5; // numar de cifre semnificative
num = 9.876;
gcvt(num, sig, str);
printf("%8.3f\tsirul = %s\n", num, str);
num = -123.4567;
gcvt(num, sig, str);
printf("%8.3f\tsirul = %s\n", num, str);
num = 0.678e5;
gcvt(num, sig, str);
printf("%8.3f\tsirul = %s\n", num, str);
return(0);
}
Prin rularea acestui program pe ecran se va afisa:
9.876 sirul = 9.876
-123.457 sirul = -123.46
67800.000 sirul = 67800

7
 Borland C++
Functii din biblioteca standard
Functii matematice
Functii pentru rotunjire
Functiile ceil, ceill, floor, floorl
Pentru rotunjire valorilor numerice se pot utilza urmatoarele functii:
 ceil si ceill – routnjire in plus;
 floor si floorl – rotunjire in minus.
Prototipurile acestor functii se gasesc in fisierul antet math.h si au urmataorele formate:
double ceil(double x);
double floor(double x);
long double ceill(long double (x));
long double floorl(long double (x));
Observatii:
 Functia ceil furnizeaza cel mai mic intreg nu mai mic decat x.
 Functia ceill furnizeaza cel mai mic intreg lung nu mai mic decat x.
 Functia floor furnizeaza cel mai mic intreg nu mai mare decat x.
 Functia floorl furnizeaza cel mai mic intreg lung nu mai mare decat x.
Valori returnate:
 Functiile ceil si floor returneaza intregul gasit ca un real dubla precizie (double);
 Functiile ceill si floorl returneaza intregul gasit ca un real extins (long double).
Exemplu:
// Exemplu pentru functiile ceil si floor
#include <math.h>
#include <stdio.h>
int main(void)
{
double number = 123.54;
double down, up;
down = floor(number);
up = ceil(number);
printf("numarul original: %5.2lf\n", number);
printf("numarul rotunjit in minus: %5.2lf\n", down);
printf("numarul rotunjit in plus: %5.2lf\n", up);
return 0;
}
Prin rularea acestui program se va afisa:
numarul original: 123.54
numarul rotunjit in minus: 123.00
numarul rotunjit in plus: 124.00
Functii pentru valorile absolute
Functiile abs, cabs, cabsl, fabs, fabsl, labs
Pentru obtinerea valorilor absolute se folosesc urmatoarele functii
 abs (macrocomanda) furnizeaza valoarea absoluta a unui intreg;
 cabs si cabsl (macrocomenzi) calculeaza valoarea absoluta a unui numar complex;
 fabs si fabsl calculeaza valoarea absoluta a unui numar in virgula mobila;
 labs calculeaza valoarea absoluta a unui inreg lung.
Prototipurile functiilor se gasesc in fisierul antet math.h si au urmatoarele formate:
Pentru valori reale:
int abs(int x);
8
 Borland C++
Functii din biblioteca standard
double cabs(struct complex z);
long double cabsl(struct _complexl (z));
double fabs(double x);
long double fabsl(long double (x));
long int labs(long int x);
Observatii:
 Toate rutinele returneaza valoarea absoluta a argumentului lor astfel:
Routin Returneaza valoarea absoluta a
a lui...
abs (Real) x, un intreg
abs (Complex) x, un real dubla precizie
cabs z, un numar complex
cabsl z, un numar complex
fabs x, un real dubla precizie
fabsl x, un real extins
labs x, un intreg lung
 Daca funtia abs este apelata atunci cand a fost inclus fisierul antet stdio.h, atunci
ea este tratata ca o macrocomanda care se extinde la codul inline. Daca vreti sa
folositi functia abs in locul macrocomenzii, atunci includeti #undef abs in programul
dvs. dupa #include <stdlib.h>.
 In C++, folositi functia abs cu tipul complex definit in fisierul antet complex.h.
 Apelarea functiilor cabs sau cabsl este echivalenta cu apelarea functiei sqrt cu
componentele reale si imaginare ale lui z:
sqrt(z.x * z.x + z.y * z.y)
Valori returnate:
abs (Real) Un intreg in intervalul 0 la 32767; un argument egal cu -32768 este returnat ca 32768
abs (Complex) Un real in dubla precizie.A double
cabs Daca operatia decurge normal, returneaza valoarea absoluta a lui z, un real in dubla precizie.
absl In caz de depasire, returneaza HUGE_VAL si seteaza errno pe ERANGE (result out of range)
fabs Un real in dubla precizie.
labs Un intreg lung
Exemple:
1. Exemplu pentru functia abs
#include <stdio.h>
#include <math.h>
int main(void)
{
int number = -1234;
printf("numar: %d valoare absoluta: %d\n", number, abs(number));
return 0;
}
Va afisa:
numar : -1234 valoare absoluta: 1234
2. Exemplu pentru functia cabs
#include <stdio.h>
#include <math.h>
#ifdef __cplusplus
#include <complex.h>
#endif
#ifdef __cplusplus // daca C++, foloseste class complex
void print_abs(void)
{
complex z(1.0, 2.0);
9
 Borland C++
Functii din biblioteca standard
double absval;
absval = abs(z);
printf("Valoarea absoluta a lui %.2lfi %.2lfj sete %.2lf",
real(z), imag(z), absval);
}
#else // Urmatoarea functie este pentru C (si nu pentru C++)
void print_abs(void)
{
struct complex z;
double absval;
z.x = 2.0;
z.y = 1.0;
absval = cabs(z);
printf("Valoarea absoluta a lui %.2lfi %.2lfj este %.2lf",
z.x, z.y, absval);
}
#endif
int main(void)
{
print_abs();
return 0;
}
Va afisa:
Valoarea absoluta a lui 1.00i 2.00j este 2.24
3. Exemplu pentru functia fabs
#include <stdio.h>
#include <math.h>
int main(void)
{
float number = -1234.0;
printf("numar: %f valoare absoluta: %f\n", number, fabs(number));
return 0;
}
va afisa:
numar –1234.0 valoare absoluta: 1234.0
4. Exemplu pentru functia labs
#include <stdio.h>
#include <math.h>
int main(void)
{
long result;
long x = -12345678L;
result= labs(x);
printf("numar: %ld valoare absoluta: %ld\n", x, result);
return 0;
}
va afisa:
numar: -12345678 valoare absoluta: 12345678

10
 Borland C++
Functii din biblioteca standard
Functii exponentiale si logaritmice
Functiile exp si expl
Pentru a calcula e la puterea x se folosesc functiile exp si expl, Prototipurile acestora se
gasesc in fisierul antet math.h si au urmatoarele formate:
double exp(double x);
long double expl(long double (x));
Valori returnata:
 Daca operatia decurge normal, functia returneaza ex. este posibil ca uneori,
argumentele transmise functie exp sa produca rezultate care depasesc sau sunt
incalculabile.
 In caz de depasire:
o exp returneaza HUGE_VAL
o expl returneaza _LHUGE_VAL. Rezultatele excesiv de mari determina ca errno
sa fie setat pe ERANGE (Result out of range).
Exemplu:
#include <stdio.h>
#include <math.h>
int main(void)
{
double result;
double x = 4.0;
result = exp(x);
printf("'e' la puterea %lf (e^%lf) = %lf\n", x, x, result);
return 0;
}
va afisa:
‘e’ la puterea 4.000000 (e^4.000000) = 54.598150
Functiile frexp si frexpl
Funtiile frexp (real dubla precizie) si frexpl (real extins) se folosesc pentru a diviza
un numar in mantisa si exponent. Prototipurile functiilor se gasesc in fisierul antet math.h si au
urmatoarele formate:
double frexp(double x, int *exponent);
long double frexp(long double (x), int *(exponent));
Observatii:
 Transmitand x (un real dubla precizie), frexp calculeaza mantisa m (un real dubla
precizie) si n (un intreg), astfel incat:
x = m * (2**n)
unde:
0.5 =< m < 1
 frexpl calculeaza mantisa si intregul pentru un real extins x.
 frexp si frexpl stocheaza n in *exponent.
Valori returnate:
 frexp si frexpl returneaza mantisa m.
Exemplu:
#include <math.h>
#include <stdio.h>
int main(void)
{
double mantissa, number = 8.0;
int exponent;
11
 Borland C++
Functii din biblioteca standard
mantissa = frexp(number, &exponent);
printf("Numarul %lf este %lf ori 2 la puterea %d\n",
number, mantissa, exponent);
return 0;
}
va afisa:
Numarul 8.000000 este 0.500000 ori 2 la puterea 4
Functiile log, logl, log10, log10l
Pentru calculul logaritmului natural se folosesc functiile log si logl, iar pentru
logaritmul zecimal functiile log10 si log10l. Prototipurile functiilor se gasesc in fisierul antet
math.h si au urmatoarele formate:
double log(double x);
double log10(double x);
long double logl(long double (x));
long double log10l(long double (x));
Observatii:
 Functiile log si log10 calculeaza logaritmul natural si respectiv logaritmul zecimal al
unui numar real dubla precizie;
 Functiile logl si log10l calculeaza logaritmul natural si respectiv logaritmul zecimal
al unui numar real extins.
Valori returnate:
 Daca operati a decurs normal:
o log si logl returneaza logaritmul natural a lui x, ca numar real dubla precizie
respectiv real extins;
o log10 si log10l returneaza logaritmul zecimal a lui x, ca numar real dubla
precizie respectvi real extins.
 In caz de eroare:
o Daca x = 0, functiile seteaza errno pe ERANGE;
o log si log10 returneaza negativ HUGE_VAL;
o logl and log10l returneaza negativ _LHUGE_VAL;
o daca x este real si mai mic ca 0, toate functiile returneaza EDOM (domain error).
Exemple:
1. Exemplu pentru functia log
#include <math.h>
#include <stdio.h>
int main(void)
{
double result;
double x = 8.6872;
result = log(x);
printf("ln(%lf) = %lf\n", x, result);
return 0;
}
va afisa:
ln(8.687200) = 2.161851
2. Exemplu pentru functia log10
#include <math.h>
#include <stdio.h>
int main(void)
{
double result;
12
 Borland C++
Functii din biblioteca standard
double x = 800.6872;
result = log10(x);
printf("log(%lf) = %lf\n", x, result);
return 0;
}
va afisa:
log(800.687200) = 2.903463
Functiile pow si powl
Pentru ridicarea la o putere a unui numar se folosesc functiile pow si powl. Prototipurile
functiilor se gasesc in fisierul math.h si au urmatoarele formate:
double pow(double x, double y);
long double pow(long double (x), long double (y));
Functiile calculeaza xy.
Valori returnate:
 Daca operatia a decurs normal, functiile returneaza xy. Daca x si y sunt egali cu 0,
functiile returneaza 1.
 Daca x este real si y este mai mic ca 0 si nu este un numar intreg, functiile seteaza
errno pe EDOM (domain error).
 Uneori argumentele transmise functiilor produc rezultate care depasesc sau sunt
incalculabile. Cand o valoare corecta produce o depasire, pow returneaza
HUGE_VAL iar powl returneaza _LHUGE_VAL.
 Rezultatele excesiv de mari pot determina ca functiile sa seteze errno pe ERANGE
(result out of range).
Exemplu:
#include <math.h>
#include <stdio.h>
int main(void)
{
double x = 2.0, y = 3.0;
printf("%lf ridicat la %lf este %lf\n", x, y, pow(x, y));
return 0;
}
va afisa:
2.000000 ridicat la 3.000000 este 8.000000
Functiile sqrt si sqrtl
Functiile sqrt si sqrtl se folosesc pentru extragerea radacinii partate. Prototipurile
acestor functii se gasesc in fisierul antet math.h si au urmatoarele formate:
double sqrt(double x);
long double sqrtl(long double @E(x));
Valori returnate:
 Functiile sqrt si sqrtl returneaza radacina patrata a lui x.
 Daca x este real si pozitiv, atunci rezultatul este pozitiv.
 Daca x este real si negativ, sqrt seteaza errno pe EDOM (domain error).
Exemplu:
#include <math.h>
#include <stdio.h>
int main(void)
{
double x = 4.0, result;
result = sqrt(x);
13
 Borland C++
Functii din biblioteca standard
printf("Radical din %lf este %lf\n", x, result);
return 0;
}
va afisa:
Radical din 4.000000 este 2.000000
Functii logaritmice
Functiile acos, asin, atan, atan2, acosl, asinl, atanl, atan2l
Functiile calculeaza arc sinus, arc cosinus si arc tangenta. Au prototipurile in fisierul
antet math.h si au urmatoarele formate:
double acos(double x);
double asin(double x);
double atan(double x);
double atan2(double y, double x);
long double acosl(long double (x));
long double asinl(long double (x));
long double atanl(long double (x));
long double atan2l(long double (y), long double (x));
Observatii:
 acos si acosl a unei valori reale calculeaza arc cosinusul valorii respective.
 asin si asinl a unei valori reale calculeaza arc sinusul valorii respective.
 atan si atanl a unei valori reale calculeaza acr tangenta valorii respective.
 atan2 si atan2l calculeaza de asemnea arc tangenta valorii de intrare
 Argumentele pentru acos, acosl, asin si asinl trebuie sa fie in intervalul –1 la 1.
Valori returnate:
 Daca operatia a decurs normal,
o acos si acosl returneaza arc cosinusul valorii de intrare (in domeniul 0 la pi);
o asin si asinl returneaza arc sinusul valorii de intrare (in domeniul –pi/2 la pi/2);
o atan si atanl returneaza arc tangenta valorii de intrare (in domeniul –pi/2 la
pi/2);
o atan2 si atan2l returneaza arc tangenta lui y/x (in domeniul –pi la pi); Ele
produc un rezultat corect chiar atunci cand unghiul rezultat este apropiat de pi/2
sau –pi/2 (x este aproape 0).
 In caz de eroare
o Daca argumentele nu sunt in intervalul –1 la 1, atunci functiile acos, acosl,
asin si asinl returneaza NAN si seteaza errno pe EDOM (domain error).
o Daca atat x cat si y sunt 0, atunci functia atan2 seteaza errno pe EDOM.
Exemple:
1. Pentru functia acos
#include <stdio.h>
#include <math.h>
int main(void)
{
double result;
double x = 0.5;
result = acos(x);
printf("arc cosinusul lui %lf este %lf\n", x, result);
return 0;
}
va afisa:
arc cosinusul lui 0.500000 este 1.047198
14
 Borland C++
Functii din biblioteca standard
2. Pentru functia asin
#include <stdio.h>
#include <math.h>
int main(void)
{
double result;
double x = 0.5;
result = asin(x);
printf("asin(%lf) = %lf\n", x, result);
return(0);
}
va afisa:
asin(0.500000) = 0.523599
3. Pentru functia atan
#include <stdio.h>
#include <math.h>
int main(void)
{
double result;
double x = 0.5;
result = atan(x);
printf("atg(%lf) = %lf\n", x, result);
return(0);
}
va afisa:
atg(0.500000) = 0.463648
4. Pentru functia atan2
#include <stdio.h>
#include <math.h>
int main(void)
{
double result;
double x = 90.0, y = 45.0;
result = atan2(y, x);
printf("atg(%lf / %lf) = %lf\n", y, x, result);
return 0;
}
va afisa:
atg(45.000000 / 90.000000) = 0.463648
Functiile cos, sin, tan, cosl, sinl, tanl
Functiile cos, sin, tan, cosl, sinl si tanl calculeaza cosinusul, sinusul si tangenta
unui unghi. Prototipurile functiilor se gasesc in fisierul antet math.h si au urmatoarele formate:
double cos(double x);
double sin(double x);
double tan(double x);
long double cosl(long double (x));
long double sinl(long double (x));
long double tanl(long double x)
Observatii:
 Functiile cos si cosl calculeaza cosinusul valorii de intrare;
 Functiile sin si sinl calculeaza sinusul valorii de intrare;

15
 Borland C++
Functii din biblioteca standard
 Functiile tan si tanl calculeaza tangenta valorii de intrare;
 Unghiurile set specifica in radiani
Valori returnate:
 Daca operatia se termina normal,
o cos and cosl returneaza cosinusul valorii de intrare (in intervalul -1 la 1);
o sin and sinl returneaza sinusul valorii de intrare (in intervalul -1 la 1);
o tan and tanl returneaza tangenta lui x, sin(x)/cos(x).
Exemple:
1. Pentru functia cos
#include <stdio.h>
#include <math.h>
int main(void)
{
double result;
double x = 0.5;
result = cos(x);
printf("cos(%lf) = %lf\n", x, result);
return 0;
}
va afisa:
cos(5.000000) = 0.877583
2. Pentru functia sin
#include <stdio.h>
#include <math.h>
int main(void)
{
double result, x = 0.5;
result = sin(x);
printf("sin(%lf) = %lf\n", x, result);
return 0;
}
va afisa:
sin(0.500000) = 0.479426
3. Pentru functia tan
#include <stdio.h>
#include <math.h>
int main(void)
{
double result, x;
x = 0.5;
result = tan(x);
printf("tg(%lf) = %lf\n", x, result);
return 0;
}
va afisa:
tg(0.500000) = 0.546302
Functii hiperbolice
Functiile cosh, sinh, tanh, coshl, sinhl, tanhl
Functiile cosh, sinh, tanh, coshl, sinhl si tanhl calculeaza cosinusul hiperbolic,
sinusul hiperbolic si tangenta hiperbolica. Prototipurile functiilor se gasesc in fisierul math.h si
au urmatoarele formate:
16
 Borland C++
Functii din biblioteca standard
double cosh(double x);
double sinh(double x);
double tanh(double x);
long double coshl(long double (x));
long double sinhl(long double (x));
long double tanhl(long double (x));
Observatii:
 Functiile cosh si coshl calculeaza cosinusul hiperbolic: (ex + e-x) / 2
 Functiile sinh si sinhl calculeaza sinusul hiperbolic: (ex - e-x) /
 Functiile tanh si tanhl calculeaza tangenta hiperbolica: sinh(x) / cosh(x)
Valori returnate:
 Daca operatia s-a terminat normal,
o cosh si coshl: cosinusul hiperbolic a lui x
o sinh si sinhl: sinusul hiperbolic a lui x
o tanh si tanhl: tangenta hiperbolica a lui x
 In caz de eroare (cand valoarea corecta va crea o depasire), cosh si sinh
returneaza HUGE_VAL cu semnul corespunzator (coshl si sinhl returneaza
_LHUGE_VAL cu semnul corespunzator) si seteaza errno la ERANGE.
Example:
1. Exemplu pentru functia cosh
#include <stdio.h>
#include <math.h>
int main(void)
{
double result;
double x = 0.5;
result = cosh(x);
printf("cosh(%lf) = %lf\n", x, result);
return 0;
}
va afisa:
cosh(0.500000) = 1.127626
2. Exemplu pentru functia sinh
#include <stdio.h>
#include <math.h>
int main(void)
{
double result, x = 0.5;
result = sinh(x);
printf("sinh(%lf) = %lf\n", x, result);
return 0;
}
va afisa:
sinh(0.50000) = 0.521095
3. Exemplu pentru functia tanh
#include <stdio.h>
#include <math.h>
int main(void)
{
double result, x;
x = 0.5;

17
 Borland C++
Functii din biblioteca standard
result = tanh(x);
printf("tanh(%lf) = %lf\n", x, result);
return 0;
}
va afisa:
tanh(0.500000) =0.462167
Functii modulo
Functiile fmod si fmodl
Functiile fmod si fmodl calculeaza x modulo y, adica restul impartirii lui x la y. Ele au
prototipurile in fisierul antet math.h:
double fmod(double x, double y);
long double fmod(long double (x), long double (y));
Observatii:
 fmod si fmodl calculeaza x modulo y. Acesta este definit ca restul f, unde
x = (ay + f)
pentru un intreg a oarecare si
0 < f < y.
Valori returnate:
 Daca x = ay + f si 0 < f < y, functiile returneaza restul f.
 Daca y = 0, functiile returneaza 0.
Exemplu:
#include <stdio.h>
#include <math.h>
int main(void)
{
double x = 5.0, y = 2.0;
double result;
result = fmod(x,y);
printf("Restul lui (%lf / %lf) este %lf\n", x, y, result);
return 0;
}
va afisa:
Restul lui (5.000000 / 2.000000) este 2.000000
Functii diverse
Functiile div si ldiv
Functiile div si ldiv impart doi intregi. Prototipurile functiilor se gasesc in fisierul antet
stdlib.h si au formatele
div_t div(int numer, int denom);
div_t ldiv(long int numer, long int denom);
Observatii:
 div imparte doi intregi si returneaza catul si restul ca un tip div_t.
 ldiv imparte doi intregi lungi si returneaza catul si restul ca un tip ldiv_t.
Semnificatia argumentelor:
 numer Numarator
 denom Numitor
Valori returnate:
 Ambele functii returneaza o structura a caror elemente sunt quot (catul) si rem
(restul).

18
 Borland C++
Functii din biblioteca standard
Exemplu:
1. Pentru functia div
#include <stdlib.h>
#include <stdio.h>
div_t x;
int main(void)
{
x = div(10,3);
printf("10 impartit la 3 = %d rest %d\n", x.quot, x.rem);
return 0;
}
va afisa:
10 impartit la 3 = 3 rest 1
2. Pentru functia ldiv
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
ldiv_t lx;
lx = ldiv(100000L, 30000L);
printf("100000 impartit la 30000 = %ld rest %ld\n",
lx.quot, lx.rem);
return 0;
}
va afisa:
100000 impartit la 30000 = 3 rest 10000
Functiile max si min
Functiile max si min returneaza maximul, respectiv minimul dintre doua valori.
Prototipurile functiilor se gasesc in fisierul antet stdlib.h si au urmatoarele formate:
(type) max(a, b);
(type) min(a, b);
Observatii:
 max si min sunt macrocomenzi care genereaza cod inline pentru gasirea maximului
sau minimului dintre doua valori. Ambele argumente si declaratii de functii trebuie sa
fie de acelasi tip.
Valori returnate:
 max returneaza cea mai mare valoare dintre cele doua transmise.
 min returneaza ce mai mica valoare dintre cele doua transmise.
Exemplu:
#include <stdlib.h>
#include <stdio.h>
#ifdef __cplusplus
int max (int value1, int value2);
int max(int value1, int value2)
{
return ( (value1 > value2) ? value1 : value2);
}
#endif
int main(void)
{
int x = 5;
int y = 6;
19
 Borland C++
Functii din biblioteca standard
int z;
z = max(x, y);
printf("Cel mai mare numar este %d\n", z);
return 0;
}
va afisa:
Cel mai mare numar este 6
Functii pentru numere aleatoare
Functia rand
Functia rand genereaza un numar. Prototipul functiei se gaseste in fisierul antet
stdlib.h si are formatul:
int rand(void);
Observatii:
 Functia rand foloseste un generator de numere aleatoare congruential multiplicativ
cu perioada 232 pentru a genera numere pseudo-aleatoare in doemniul 0 la
RAND_MAX.
Valoare returnata: un numar pseudo-aleator.
Exemplu:
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
int i;
printf("Zece numere aleatoare in intervalul 0 la 99:\n");
for(i=0; i<10; i++)
printf("%d ", rand() % 100);
return 0;
}
va afisa:
Zece numere aleatoare in intervalull 0 la 99:
46 30 82 90 56 17 95 15 48 36
Functia (macrocomanda) random
Pentru obtinerea unui numar intreg aleator se poate folosi functia (macrocomanda)
random. Prototipul se gaseste in fisierul stdlib.h si are forma:
 Macrocomanda:
random(num);
 Functia:
int random(int num);
Observatii:
 random returneaza un numar aleator cuprins intre 0 si num – 1.
Exemplu:
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
// afiseaza un numar aleator in intervalul 0 la 99
int main(void)
{
randomize();
printf("Numar aleator in intervalul 0-99: %d\n", random (100));
return 0;

20
 Borland C++
Functii din biblioteca standard
}
va afisa:
Numar aleator in intervalul 0-99: 89
Macrocomanda randomize
Macrocomanda randomize initializeaza generatorul de numere aleatoare. Prototipul ei
se afla in fisierul antet stdlib.h si are forma:
void randomize(void);
Observatii:
 randomize initializeaza generatorul de numere aleatoare cu o valoare aleatoare.
 Deoarece randomize este implementat ca o macrocomanda care apeleaza functii de
timp ce au prototipurile in fisierul antet time.h, cand folositi aceasta rutina trebuie sa
includeti time.h.
 Nu returneaza valori.
Exemplu:
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
int main(void)
{
int i;
randomize();
printf("Zece numere aleatoare de la 0 la 99:\n");
for(i=0; i<10; i++)
printf("%d ", rand() % 100);
return 0;
}
Nota: La fiecare rulare a acestui program se vor obtine 10 numere aleatoare diferite.
In cazul exemplului de la functia rand (vezi pag. 20) la fiecare rulare se
generau aveleasi numere aleatoare.
Functia srand
Functia srand initializeaza generatorul de numere aleatoare. Prototipul functiei se afla
in fisierul antet stdlib.h si are urmatorul format:
void srand(unsigned seed);
Observatii:
 Generatorul este reinitializat prin apelarea functiei srand cu un argument egal cu 1.
 Generatorul poate fi setat pentru un nou punct de incepere apeland srand cu un alt
numar.
 Nu retirneaza valori
Exemplu:
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
int main(void)
{
int i;
time_t t;
srand((unsigned) time(&t));
printf("Zece numere aleatoare de la 0 la 99: \n");
for(i=0; i<10; i++)
printf("%d ", rand() % 100);
return 0;
21
 Borland C++
Functii din biblioteca standard
}

22
 Borland C++
Functii din biblioteca standard

Functii pentru cautare/sortare

Functiile bsearch, lfind, lsearch si qsort
Aceste functii se folosesc pentru:
 bsearch executa o cautare binara
 lfind si lsearch executa o cautare liniara
 qsort sorteaza valorile folosind algoritmul quicksort
Prototipurile functiilor se gasesc in fisierele antet stdlib.h si search.h si au
urmatoarele formate:
void *bsearch(const void *key, const void *base, size_t nelem,
size_t width, int (*fcmp)(const void*, const void*));
void *lfind(const void *key, const void *base, size_t *num,
size_t width, int (*fcmp)(const void *, const void*));
void *lsearch(const void *key, void *base, size_t *num,
size_t width, int (*fcmp)(const void *, const void *));
void qsort(void *base, size_t nelem, size_t width,
int (*fcmp)(const void *, const void *));
Observatii:
Functia Executa
bsearch Realizeaza o cautare binara pentru valoarea *key intr-un tablou de nelem elemente din
memorie.
lfind Realizeaza o cautare lineara pentru valoarea *key dintr-un tablou de articole secventiale.
lsearch Realizeaza o cautare lineara pentru valoarea *key intr-o tabela. Daca *key nu este in tabela,
o adauga..
qsort Reprezinta o implementare a algoritmului de sortare numit quiclsort.
Argumente
Argumen Ce este sau ce refera
t
base Baza (elementul 0) al tabelei de cautat.
fcmp O rutina de comparare definita de utilizator pentru compararea a doua elemente si
returnarea unei valori bazata pe comparatie.
key Elementul de cautat (cheia de cautare)
nelem Numarul intrarilor din tabela.
num Numarul intrarilor din tabela.
width Numarul de bytes din fiecare intrare.
 Deoarece lsearch executa o cautare lineara, intrarile tabelei nu trebuie sa fie sortate
inainte de apelarea functiei.
 Deoarece bsearch executa o cautare binara, nu este necesar ca prima intrare din
tabela sa fie prima intrare care corespunde criteriului.
Valori returnate:
Functia In caz de esec In caz de succes
bsearch 0 (Nu corespunde) Adresa primeimintrari din tabela
lfind NULL (Nu corespunde) care corespunde cheii de cautare.
lsearch
qsort Nu Nu
Exemple:
1. Pentru functia bsearch
#include <stdlib.h>
#include <stdio.h>
typedef int (*fptr)(const void*, const void*);
#define NELEMS(arr) (sizeof(arr) / sizeof(arr[0]))
23
 Borland C++
Functii din biblioteca standard
int numarray[] = {123, 145, 512, 627, 800, 933};
int numeric (const int *p1, const int *p2)
{
return(*p1 - *p2);
}
#pragma argsused
int lookup(int key)
{
int *itemptr;
// cast of (int(*)(const void *,const void*)) este necesar
// pentru a se evita o eroare de neconcordanta a tipului
// la compilare
itemptr = (int *) bsearch (&key, numarray, NELEMS(numarray),
sizeof(int), (fptr)numeric);
return (itemptr != NULL);
}
int main(void)
{
if (lookup(512))
printf("512 este in tabela.\n");
else
printf("512 nu este in tabela.\n");
return 0;
}
va afisa:
512 este in tabela.
2. Exemplu pentru functia lfind
#include <stdio.h>
#include <stdlib.h>
int compare(int *x, int *y)
{
return( *x - *y );
}
int main(void)
{
int array[5] = {35, 87, 46, 99, 12};
size_t nelem = 5;
int key;
int *result;
key = 99;
result = (int *) lfind(&key, array, &nelem,
sizeof(int), (int(*)(const void *,const void *))compare);
if (result)
printf("Numarul %d a fost gasit.\n",key);
else
printf("Numarul %d nu a fost gasit.\n",key);
return 0;
}
va afisa:
Numarul 99 a fost gasit.
3. Exemplu pentru functia lsearch
#include <stdlib.h>
#include <stdio.h>
24
 Borland C++
Functii din biblioteca standard
#include <string.h> // pentu apelarea fucntie strcmp
char *colors[10] = { "Red", "Blue", "Green" };
int ncolors = 3;
int colorscmp(char **arg1, char **arg2)
{
return(strcmp(*arg1, *arg2));
}
int addelem(char *key)
{
int oldn = ncolors;
lsearch(&key, colors, (size_t *)&ncolors, sizeof(char *),
(int(*)(const void *,const void *))colorscmp);
return(ncolors == oldn);
}
int main(void)
{
int i;
char *key = "Purple";
if (addelem(key))
printf("Culoarea %s este deja in tabela culorilor.\n", key);
else
{
strcpy(colors[ncolors-1],key);
printf("Culoarea %s se adauga in tabela culorilor.\n", key);
}
printf("Culorile sunt:\n");
for (i = 0; i < ncolors; i++)
printf("%s\n", colors[i]);
return 0;
}
va afisa:
Culoarea Purple se adauga in tabela culorilor.
Culorile sunt:
Red
Blue
Green
Purple
4. Exemplu pentru functia qsort
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int sort_function( const void *a, const void *b)
{
return(strcmp((char *)a,(char *)b));
}
char list[5][4] = { "cat", "car", "cab", "cap", "can" };
int main(void)
{
int x;
qsort((void *)list, 5, sizeof(list[0]), sort_function);
printf("Lista sortata este: \n");
for (x = 0; x < 5; x++) printf("%s ", list[x]);
return 0;

25
 Borland C++
Functii din biblioteca standard
}
va afisa:
Lista sortata este:
cab can cap car cat

Functii pentru terminarea programulu

Functia abort
Pentru terminarea anormala a unui proces se foloseste functia abort. Prototipul functiei
se gaseste in fisierele antet stdlib.h si process.h, avand urmatorul format:
void abort(void);
Observatie:
 Functia abort scrie mesajul de terminare in fisierul stderr (Abnormal program
termination), apoi abandoneaza programul printr-un apel la _exit(3).
Valoare returnata:
 Returneaza procesului parinte sau sistemului de operare codul de iesire 3.
Exemplu:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
printf("Apelarea functiei abort()\n");
abort();
return 0; // Nu este executata niciodata
}
Functiile exit
Functia exit se foloseste pentru a termina un program. Prototipul functiei se gaseste in
fisierele antet process.h si stdlib.h si are urmatorul format:
void exit(int status);
Observatii:
 exit termina procesul apelat. Inainte de terminare, functia executa urmatoarele:
o Inchide toate fisierele;
o scrie informatia din bufferele de iesire (asteapta pentru a fi scrise)
o apeleaza orice "exit functions" inregistrata (transmisa cu functia atexit)
 Argumentul status indica programului apelant modul de terminare a unui proces.
Valoarea 0 pentru status indica terminare normala; o valoare diferita de zero indica
terminare cu erori. Setarea argumentului status se poate realiza folosind urmatoarele
constante:
status Indica
EXIT_SUCCESS Terminarea normala a programului.
EXIT_FAILURE Terminarea anormala a programului. Semnaleaza sistemului
de operare ca programul a fost terminat cu erori.
 Nu returneaza valori
Exemple:
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
int main(void)
{
int status;

26
 Borland C++
Functii din biblioteca standard
printf("Introduceti 1 sau 2: ");
status = getch();
// Seteaza nivelul de eroare MS-DOS
exit(status - '0');
// Nota: aceasta linie nu va fi executata niciodata
return 0;
}

Functii de timp si data

Prototipurile functiilor de timp si data se gasesc in fisierul antet time.h. Tot in acest
fisier sunt definite trei tipuri de reprezentare a timpului si date si doua macrocomenzi.
Tipuri pentru reprezentarea timpului si datei
Cele trei structuri pentru reprezentarea datei si timpului sunt: tm, time_t si clock_t.
 Tipul tm este definit astfel:
struct tm
{
int tm_sec; // Secunde, 0-59
int tm_min; // Minute, 0-59
int tm_hour; // Ore (0--23)
int tm_mday; // Ziua din luna (1-31)
int tm_mon; // Luna (0-11)
int tm_year; // Anul (anul calendaristic minus 1900)
int tm_wday; // Ziua din saptamana, incepand cu duminica (0-6)
int tm_yday; // Ziua din an, incepand de la 1 ianuarie (0-365)
int tm_isdst; // indicator pentru schimbarea fusului orar
};
tm este o structura care defineste timpul broken-down. Aceasta structura este utilizata
de functiile: asctime, gmtime, localtime, mktime si strftime.
 Tipul time_t reprezinta timpul si data sistemului ca un intreg. Acesta este denumit
calendar time.
 Tipul clock_t este returnat de functia clock si contine timpul scurs din momentul
lansarii in executie a programului. Timpul este masurat in impulsuri de ceas. Numarul
de impulsuri pe secunda este definit de constanta CLK_TCK.
Functii pentru conversia date si timpului in sir de caractere
Pentru conversia timpului si datei intr-un sir de caractere exista doua functii si anume:
 asctime – care converteste in zona indicata sub forma unui sir de 26 caractere
timpul si data stocat intr-o structura. Prototipul functiei este:
char *asctime(const struct tm *tblock);
unde: tblock este zona in care se executa conversia datei si timpului.
 ctime – care convertestevaloarea timpului intr-un sir de 26 caractere. Prototipul
functiei este:
char *ctime(const time_t *time);
unde : time este zona in care se obtine sirul prin conversia valorii timpului.
Sirul de 26 caractere obtinut prin conversie este terminat cu caracterul newline (\n) si un
caracter null (\0) si are urmatorul format:
DDD MMM dd hh:mm:ss YYYY
unde:
DDD = Ziua (Mon, Tue, Wed, etc.)
27
 Borland C++
Functii din biblioteca standard
MMM = Luna (Jan, Feb, Mar, etc.)
dd = Data (1, 2, ..., 31)
hh = Ora (1, 2, ..., 24)
mm = Minutele (1, ..., 59)
ss = Secundele (1, ..., 59)
YYYY = An
Spre exemplu:
Mon Oct 20 11:31:54 1952
Toate campurile au lungime constanta
Valori returnate:
Ambele functii returneaza un pointer spre sirul de caractere care contine data si timpul.
Acest sir este o variabila statica, care este rescrisa de fiecare data cand se apeleaza functia.
Exemple:
1. Exemplu pentru functia asctime
#include <string.h>
#include <time.h>
#include <stdio.h>
int main(void)
{
struct tm t; // declararea unei variabile a tipului tm
char str[80]; // variabila care va contine data si timpul convertit
// Incarcarea structurii tm
t.tm_sec = 1; // Secunde
t.tm_min = 30; // Minute
t.tm_hour = 9; // Ora
t.tm_mday = 22; // Ziua din luna
t.tm_mon = 11; // Luna
t.tm_year = 102; // Anul – nu se include secolul
t.tm_wday = 4; // Ziua din saptamana
t.tm_yday = 0; // Nu este afisat de asctime
t.tm_isdst = 0; // Nu este afisat de asctime
// Conversia structurii intr-un sir de caractere
strcpy(str, asctime(&t));
printf("%s\n", str);
return 0;
}
va afisa:
Thu Dec 22 09:30:01 2002
2. Exemplu pentru functia ctime
#include <stdio.h>
#include <time.h>
int main(void)
{
time_t t; // declarare unei variabile a tipului time_t
time(&t); // obtinerea datei si timpului sitsemului
printf("Data si timpul sistemului este: %s\n", ctime(&t));
return 0;
}
programul va afisa:
Data si timpul sistemului este: Fri Jun 21 10:18:59 2002

28
 Borland C++
Functii din biblioteca standard
Functii pentru obtinerea si stabilirea timpului si datei
Pentru a obtine timpul scurs de la 01/01/1970 se foloseste functia time, iar pentru a
seta data si timpul sistemului se utilizeaza functia stime. Prototipurile functiilor sunt:
time_t time(time_t *timer);
int stime(time_t *tp);
Observatii:
 Functia time furnizeaza timpul, in secunde, scurs de la 1 ianuarie 1970 (00:00:00
GMT). Aceasta valoare este stocata in zona referita de *timer,
 Functia stime seteaza data si timpul sistemului, masurat in secunde de la 01.01.197
(00:00:00 GMT). Variabila tp refera valoarea timpului exprimat in secunde.
Valori returnate:
 Functia time returneaza timpul scurs in secunde.
 Functia stime returneaza 0.
Exemple:
1. Exemplu pentru functia time
#include <time.h>
#include <stdio.h>
#include <dos.h>
int main(void)
{
time_t t;
t = time(NULL);
printf("Numarul de secunde de la 1 Ianuarie, 1970 este %ld",t);
return 0;
}
va afisa:
Numarul de secunde de la 1 Ianuarie, 1970 este 1024761177
2. Exemplu pentru functia stime
#include <stdio.h>
#include <time.h>
int main(void)
{
time_t t;
t = time(NULL);
printf("Data curenta este %s", ctime(&t));
t -= 24L*60L*60L; // Se da data si timpul cu o zi inapoi
stime(&t);
printf("Noua data este %s", ctime(&t));
return 0;
}
La rularea acestui program, pe ecran se obtine:
Data curenta este: Sat Jun 22 11:57:55 2002
Noua data este Fri Jun 21 11:57:55 2002
Functii pentru conversia datei si timpului la o structura
Aceste functii se folosesc astfe:
 gmtime converteste data si timpul la Greenwich Mean Time (GMT)
 localtime converteste data si timpul pentru o structura
Prototipurile functiilor se gasesc in fisierul antet time.h si au urmatoarele formate:
struct tm *gmtime(const time_t *timer);
struct tm *localtime(const time_t *timer);
29
 Borland C++
Functii din biblioteca standard
Observatii:
 argumentul timer refera locatia valorii de tip time_t returnata de functia time.
 Ambele functii accepta adresa unei valori returnate de functia time si returneaza un
pointer la o structura tm care contine timpul broken-down.
 Functia gmtime converteste direct la GMT.
 Functia localtime corecteaza pentru fusul orar si posibilul orar.
o Setaaza variabila globala timezone (folosita de functiile pentru timp si data)
la diferenta in secunde dintre GMT si timpul standard local. In PST (Pacific
Standard Time), timezone = 8(hrs) * 60(min/hr) * 60(sec/min)
o Seteaza variabila globala daylight la o valoare diferita de zero si numai daca
se va aplica conversia la orarul U.S.
Valori returnate:
 Functiile gmtime si localtime returneaza un pointer la o structura tm care contine
timpul broken-down. Aceasta este structura statica care va fi rescrisa la fiecare apel.
Exemple:
1. Exemplu pentru functia gmtime
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <dos.h>
/* Pacific Standard Time & Daylight Savings */
char *tzstr = "TZ=PST8PDT";
int main(void)
{
time_t t;
struct tm *gmt, *area;
putenv(tzstr);
tzset();
t = time(NULL);
area = localtime(&t);
printf("Timpul loca este: %s", asctime(area));
gmt = gmtime(&t);
printf("GMT este: %s", asctime(gmt));
return 0;
}
Iesirea afisata poate fi de forma:
Timpul local este: Mon Jun 24 12:19:35 2002
GMT este: Mon Jun 24 19:19:35 2002
2. Exemplu pentru functia localtime
#include <time.h>
#include <stdio.h>
#include <dos.h>
int main(void)
{
time_t timer;
struct tm *tblock;
timer = time(NULL);
tblock = localtime(&timer);
printf("Timpul local este: %s", asctime(tblock));
return 0;
}
va afisa:
30
 Borland C++
Functii din biblioteca standard
Timpul local este: Mon Jun 12:24:58 2002
Functii pentru conversia timpului in format calendar
Functia mktime asigura conversia timpului si datei la formatul calendar. Prototipul
functiei se afla in fisierul antet time.h si are urmatorul format:
time_t mktime(struct tm *t);
Observatii:
 Converteste timpul din structura *t intr-un timp calendar cu acelasi format ca si cel
folosit de functia time.
 Valorile originale ale campurilor tm_sec, tm_min, tm_hour, tm_mday si tm_mon nu
sunt restrictionate de intervalele descrise in structura tm.
 Daca valorile campurile nu sunt in intervalul corespunzator, functia mktime le
ajusteaza.
 Functia mktime calculeaza valorile pentru tm_wday si tm_yday dupa ce au fost
ajustate celelalte campuri.
Exemplu:
#include <stdio.h>
#include <time.h>
char *wday[] = {"Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday", "Unknown"};
int main(void)
{
struct tm time_check;
int year, month, day;
printf("Anul: "); scanf("%d", &year);
printf("Luna: "); scanf("%d", &month);
printf("Ziua: "); scanf("%d", &day);
time_check.tm_year = year - 1900;
time_check.tm_mon = month - 1;
time_check.tm_mday = day;
time_check.tm_hour = 0;
time_check.tm_min = 0;
time_check.tm_sec = 1;
time_check.tm_isdst = -1;
if (mktime(&time_check) == -1)
time_check.tm_wday = 7;
printf("Astazi este %s\n", wday[time_check.tm_wday]);
return 0;
}
va afisa:
Astazi este: Monday
Functii pentru formatarea timpului
Pentru formatarea timpului se poate utiliza functia strftime, al carui prototip din fisierul
antet time.h este:
size_t _cdecl strftime(char *s, size_t maxsize,
const char *fmt, const struct tm *t);
Observatii:
 strftime formateaza timpul din *t in tabloul *s in concordanta cu specificatiile de
format (un sir de formatare) din *fmt.
 Toate caracterele obisnuite sunt copiate nemodificate. In tabloul s nu se vor plasa mai
mult de maxsize caractere.
31
 Borland C++
Functii din biblioteca standard
Valori returnate:
 Daca operatia a decurs normal, functia returneaza numarul caracterelor plasate in
tabloul s.
 In caz de eroare (daca numarul de caractere solicitat este mai mare decat maxsize),
functia returneaza 0.
Exemplu:
#include <stdio.h>
#include <time.h>
#include <dos.h>
int main(void)
{
struct tm *time_now;
time_t secs_now;
char str[80];
tzset();
time(&secs_now); time_now = localtime(&secs_now);
strftime(str, 80,
"Acum sunt %M minute dupa ora %I (%Z) %A, %B %d 20%y",
time_now);
printf("%s\n",str);
return 0;
}
va afisa:
Acum sunt 5 minute dupa ora 01 (EDT) Monday, June 24 2002
Functii pentru impulsurile ceasului
Pentru o obtine numarul de impulsuri de ceas scurse de la lansarea programului se
poate utiliza functia clock. Prototipul functiei se afla in fisierul antet time.h si are urmatorul
format:
clock_t clock(void);
Observatii:
 Functia clock poate fi utilizata pentru a determina intervalul de timp dintre doua
evenimente.
 Pentru a determina timpul in secunde se imparte valoarea returnata de clock la
valoarea CLK_TCK.
Valori returnate:
 In caz de reusita, functia returneaza timpul procesorului scurs de la lansarea in
executie a programului.
 In caz de esec (timpul procesorului nu este accesibil sau valoarea lui nu poate fi
reprezentata), functia returneaza -1.
Exemplu:
#include <time.h>
#include <stdio.h>
#include <dos.h>
long i = MAXLONG/100;
void main(void)
{
clock_t start, end;
start = clock();
for(; i; i--);
end = clock();
printf("Durata a fost: %f secunde.\n", (end - start) / CLK_TCK);

32
 Borland C++
Functii din biblioteca standard
}
va afisa:
Durata a fost: 2.472527 secunde.
Conversia datei si timpului in siruri
Functia _strdate
Functia _strdate se foloseste pentru a converti data curenta intr-un sir de caractere.
Prototipul functiei se gaseste in fisierul time.h si are urmatorul format:
char *_strdate(char *buf);
Observatii:
 _strdate converteste data curenta intr-un sir de caractere si stocheaza sirul in zona
*buf.
 Zona *buf trebuie sa aiba cel putin 9 caractere.
 Sirul convertit este terminat printr-un caracter null si are forma: MM/DD/YY; unde:
MM = luna; DD = zi; YY = an; MM, DD si YY sunt toate din doua cifre.
Valoare returnata: Returneaza adresa zonei in care se gaseste sirul convertit (buf).
Functia _strtime
Functia _strtime converteste timpul curent intr-un sir de caractere. Prototipul functiei
se gaseste in fisierul time.h si are urmatorul format:
char *_strtime(char *buf);
Observatii:
 _strtime converteste timpul curent intr-un sir de caractere si stocheaza sirul in zona
*buf.
 Zona *buf trebuie sa aiba cel putin 9 caractere.
 Sirul convertit este terminat printr-un caracter null si are forma: HH:MM:SS; unde:
HH = ora; MM = minut; SS = seconda HH, MM si SS sunt toate din doua cifre.
Valoare returnata: Returneaza adresa zonei in care se gaseste sirul convertit (buf).
Exemplu:
#include <time.h>
#include <stdio.h>
void main(void)
{
char datebuf[9];
char timebuf[9];
_strdate(datebuf);
_strtime(timebuf);
printf("Data: %s Timpul: %s\n",datebuf,timebuf);
}
va afisa:
Data: 06/24/02 Timpul: 16:55:14

33