Funcții predefinite C/C++

Biblioteca standard C++ oferă funcții gata scrise pentru calcule și prelucrări obișnuite. În <cmath> se află sqrt (rădăcina pătrată), floor (cel mai mare întreg care nu depășește argumentul), ceil (cel mai mic întreg care nu este sub argument), round (rotunjirea la cel mai apropiat întreg) și pow (puterea). Funcția abs dă modulul. În <algorithm> se află min, max și sort. Funcțiile se pot scrie cu prefixul std:: sau, după using namespace std;, direct.

#include <cmath>
#include <algorithm>
double a = std::sqrt(25.0);
double b = std::floor(-2.3);
int c = std::max(4, 7);

Valorile sunt $a=5$, $b=-3$ și $c=7$. Alegerea antetului și a tipului rezultatului este parte a rezolvării, nu un detaliu de scriere.

Funcțiile matematice primesc frecvent valori în virgulă mobilă și întorc tot valori în virgulă mobilă. sqrt(2) întoarce o aproximație de tip real, nu un întreg. pow(2, 3) este tot un real, cu valoarea 8; pentru puteri întregi mici, o înmulțire repetată între întregi evită conversiile și erorile de rotunjire. floor(-2.3) este $-3$, iar ceil(-2.3) este $-2$; conversia la int, (int)(-2.3), trunchiază spre zero și dă $-2$. Funcția round rotunjește la cel mai apropiat întreg, iar valorile aflate exact la jumătate se rotunjesc departe de zero: round(2.5) este 3 și round(-2.5) este $-3$.

Exemplul 1 — funcțiile din <cmath>.

#include <iostream>
#include <cmath>
using namespace std;
int main() {
    cout << sqrt(25.0) << ' ' << floor(-2.3) << ' ' << ceil(-2.3) << ' '
         << round(2.5) << ' ' << round(-2.5) << ' ' << (int)(-2.3) << ' '
         << abs(-4) << ' ' << pow(2, 3) << ' ' << pow(2, 10);
    return 0;
}

Programul afișează 5 -3 -2 3 -3 -2 4 8 1024. Valorile de tip real care sunt întregi se afișează fără parte zecimală. Variantele cu sqrt(10.0) și atribuirea int x = sqrt(10.0); dau x = 3, pentru că $\sqrt{10}\approx 3,16$ iar conversia elimină partea zecimală. Pentru numere reale se folosește fabs sau abs din <cmath>; pentru întregi, abs din <cstdlib>.

Exemplul 2 — min, max și sort. Funcțiile min și max cer două argumente de același tip: max(4, 7) este 7, dar min(2, 3.5) nu este un apel valid fără o conversie explicită, pentru că argumentele au tipuri diferite. Funcția sort(a, a + n) ordonează crescător primele $n$ elemente ale unui tablou; al doilea parametru este adresa de după ultimul element, deci intervalul este semi-deschis.

#include <iostream>
#include <algorithm>
using namespace std;
int main() {
    int v[] = {3, 1, 2, 5, 4};
    sort(v, v + 5);
    for (int x : v) cout << x << ' ';
    cout << min(4, 7) << ' ' << max(4, 7);
    return 0;
}

Programul afișează 1 2 3 4 5 4 7: tabloul ordonat urmat de minimul și maximul perechii 4 și 7. Pentru un vector, apelul este sort(v.begin(), v.end()).

Exemplul 3 — funcțiile într-o problemă. Distanța dintre punctele $(1;2)$ și $(4;6)$ este $\sqrt{(4-1{)}^2+(6-2{)}^2}=\sqrt{25}=5$. Pentru a împărți 17 obiecte în cutii de câte 5, numărul de cutii este cel mai mic întreg care nu este sub $17/5=3,4$, adică ceil(17 / 5.0), egal cu 4; scrisă cu operanzi întregi, 17 / 5 ar da 3 și o cutie ar lipsi. Rotunjirea unui număr la două zecimale se face cu round(x * 100) / 100: pentru 3,14159 rezultatul este 3,14.

int x1 = 1, y1 = 2, x2 = 4, y2 = 6;
double d = sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
int cutii = ceil(17 / 5.0);
double r = round(3.14159 * 100) / 100;
cout << d << ' ' << cutii << ' ' << r;

Secvența afișează 5 4 3.14. Argumentele funcțiilor pot fi expresii, iar rezultatul unei funcții poate intra într-o altă expresie sau în alt apel, de pildă sqrt(abs(x)).

Exemplul 4 — sortare descrescătoare cu o funcție de comparare. Implicit, sort ordonează crescător. Pentru ordinea inversă, al treilea argument este o funcție care întoarce true când primul element trebuie să stea înaintea celui de-al doilea.

bool maiMare(int a, int b) { return a > b; }
int v[] = {3, 1, 2, 5, 4};
sort(v, v + 5, maiMare);

După apel, tabloul este 5, 4, 3, 2, 1. Aceeași ordine se obține cu greater<int>() din <functional>. Funcția de comparare nu trebuie să folosească >=: pentru două elemente egale ar întoarce true, iar rezultatul ordonării ar deveni nedefinit.

Exemplul 5 — numărul de cifre cu log10. Pentru $n\ge 1$, numărul cifrelor este (int)log10(n) + 1. Pentru $n=12345$ avem ${\log }_{10}n\approx 4,09$, partea întreagă este 4, deci numărul are 5 cifre. Pentru $n=999$ avem ${\log }_{10}n\approx 2,9996$, deci 3 cifre, iar pentru $n=1000$ avem ${\log }_{10}n=3$, deci 4 cifre. Metoda cere antetul <cmath>, iar rezultatul lui log10 este real, de aceea conversia la int este necesară. Pentru $n=0$ funcția log10 nu este definită, așa că acest caz se tratează separat: numărul 0 are o cifră, iar pentru $n=7$ formula dă $0+1=1$ cifră.

În C++, verifică antetul, tipul argumentelor și tipul rezultatului. floor(-2.3) dă $-3$, iar conversia valorii $-2,3$ la int dă $-2$ prin trunchiere spre zero. round(-2.5) dă $-3$. int x = sqrt(10.0); atribuie 3 după conversie, pierzând partea fracționară. Rezultatul lui pow este real: (int)pow(5, 2) este 25, dar pow lucrează cu numere reale, iar rezultatul poate diferi de valoarea exactă cu o fracțiune foarte mică; conversia la int trunchiază, deci pătratul unui întreg se calculează sigur prin x * x.

În C, funcțiile matematice corespondente se declară în <math.h>, fără std::. min, max și sort aparțin bibliotecii C++, nu limbajului C. Dacă problema cere C, minimul se calculează prin comparație, iar sortarea prin algoritmul studiat. Pentru un tablou a cu $n$ elemente, sort(a, a + n) ordonează indicii de la 0 la $n-1$; a[n] nu face parte din interval.

Exemplu în formatul examenului. Ce se afișează în urma executării secvenței de mai jos?

cout << (int)sqrt(50.0) << ' ' << (int)floor(-1.5) << ' ' << (int)round(2.5) << ' ' << (int)(-1.5);

• a) 7 -2 3 -1
• b) 7 -1 3 -1
• c) 7 -2 2 -1
• d) 8 -2 3 -2

Răspunsul corect este a). Rădăcina pătrată a lui 50 este aproximativ 7,07, iar conversia la int dă 7. Funcția floor(-1.5) dă $-2$, cel mai mare întreg care nu depășește $-1,5$. Funcția round(2.5) dă 3, pentru că valorile de la jumătate se rotunjesc departe de zero. Conversia (int)(-1.5) trunchiază spre zero și dă $-1$. Varianta b) confundă floor cu trunchierea, varianta c) aplică regula Python a rotunjirii la întregul par, iar varianta d) rotunjește rădăcina în sus.

Greșeli frecvente

• Greșit: floor(-2.3) este -2, ca la conversia la int.
  Corect: floor dă -3; conversia la int trunchiază spre zero și dă -2.
• Greșit: min(2, 3.5) este un apel valid.
  Corect: argumentele au tipuri diferite, deci este nevoie de o conversie explicită.
• Greșit: std::min, std::max și std::sort există în limbajul C.
  Corect: aparțin bibliotecii C++, iar în C se scriu prin comparații și algoritmi proprii.

Înainte și după