Funcții

Definirea și declararea funcțiilor

O funcție definește acțiunile pe care le execută programul. Funcțiile permit izolarea unui set de instrucțiuni și atribuirea unui nume acestora. Ulterior, funcția poate fi apelată de mai multe ori în diferite părți ale programului folosind numele său. În esență, o funcție este un bloc de cod denumit.

Definirea formală a unei funcții arată astfel:

tip nume_funcție(parametri)
{
    instrucțiuni
}

Prima linie reprezintă antetul funcției. La început se specifică tipul de returnare al funcției. Dacă funcția nu returnează nicio valoare, se folosește tipul void.

Urmează numele funcției, care este un identificator arbitrar. Regulile de denumire a funcțiilor sunt aceleași ca și pentru variabile.

După numele funcției, între paranteze, sunt listați parametrii. Funcția poate să nu aibă parametri — în acest caz, se folosesc paranteze goale.

După antet urmează corpul funcției, între acolade, care conține instrucțiunile de executat.

Pentru a returna un rezultat, funcția utilizează operatorul return. Dacă funcția are un tip de returnare diferit de void, ea trebuie să returneze o valoare corespunzătoare cu ajutorul operatorului return.

De exemplu, definirea funcției main, care trebuie să existe în orice program C++ și cu care începe execuția:

int main()
{
    return 0;
}

Tipul de returnare este int, așadar funcția trebuie să folosească return și să întoarcă o valoare de tip int.

Merită menționat că C++ permite omiterea operatorului return în funcția main:

int main()
{

}

Dar dacă funcția are tipul void, nu trebuie să returneze nimic. De exemplu, putem defini următoarea funcție care afișează un text:

void hello()
{
    std::cout << "hello" << std::endl;
}

Executarea funcției

Când este lansat un program C++, se pornește funcția main. Nicio altă funcție nu se execută automat. Pentru a fi executată, o funcție trebuie apelată. Apelul se face astfel:

nume_funcție(argumente);

După numele funcției se scriu între paranteze argumentele — valorile pentru parametri.

De exemplu, definim și apelăm o funcție simplă:

#include <iostream>

void hello()
{
    std::cout << "hello" << std::endl;
}

int main()
{
    hello();
    hello();
}

Aici este definită funcția hello, care este apelată de două ori în main. Aceasta este și ideea funcțiilor: putem separa acțiuni comune în funcții și apoi să le folosim de câte ori dorim. Programul va afișa:

hello  
hello

Declararea funcției

Când folosim funcții, trebuie să ținem cont că compilatorul trebuie să cunoască funcția înainte de apelul ei. Așadar, apelul funcției trebuie să vină după definirea ei, ca în exemplul de mai sus. În unele limbaje acest lucru nu contează, dar în C++ este important. Dacă, de exemplu, apelăm funcția înainte să o definim, vom primi o eroare la compilare:

#include <iostream>

int main()
{
    hello();
    hello();
}

void hello()
{
    std::cout << "hello" << std::endl;
}

În acest caz, trebuie să declarăm funcția înainte de apel. Declararea este numită și prototip. Forma generală este:

tip nume_funcție(parametri);

Este, practic, antetul funcției. Pentru funcția hello, declarația arată astfel:

void hello();

Să folosim această declarație:

#include <iostream>

void hello();

int main()
{
    hello();
    hello();
}

void hello()
{
    std::cout << "hello" << std::endl;
}

În acest caz, deși definirea funcției este după apel, deoarece funcția a fost declarată înainte, compilatorul o cunoaște și programul se va compila și executa fără probleme.