Operatorul return și returnarea rezultatului

Pentru a returna un rezultat dintr-o funcție se utilizează operatorul return. Acest operator are două forme:

return expresie;
return;

Prima formă a operatorului return se aplică pentru a returna un rezultat din funcție. Dacă funcția are un tip de întoarcere diferit de void, atunci este obligatoriu să returneze o valoare prin return. Valoarea returnată trebuie să corespundă tipului de întoarcere sau să poată fi convertită implicit la acel tip.

Singura funcție care returnează o valoare, dar unde nu e obligatoriu să folosim return, este funcția main.

De exemplu, dacă vrem să scriem un program care calculează suma a două numere, putem defini o funcție care returnează această sumă:

#include <iostream>
 
int sum(int, int);
 
int main()
{
    int result = sum(10, 6);    // 16
    std::cout << result << std::endl;
    std::cout << sum(10, 7) << std::endl;   // 17
    std::cout << sum(10, 8) << std::endl;   // 18
}
 
int sum(int n, int m)
{
    int res = n + m;
    return res;
}

Funcția sum acceptă două argumente de tip int și returnează un int, deci prototipul arată așa:

int sum(int, int);

În acest caz, trebuie să folosim return pentru a întoarce rezultatul:

int res = n + m;
return res;

În acest caz este returnată valoarea variabilei res. Deși putea fi și o expresie mai complexă care returnează un int, de exemplu:

int sum(int n, int m)
{
    return n + m;
}

Deoarece funcția sum returnează o valoare, putem atribui rezultatul acesteia unei variabile sau constante:

int result = sum(10, 6);    // 16
std::cout << result << std::endl;

Sau putem folosi direct rezultatul funcției sum ca un număr, de exemplu în afișarea pe consolă:

std::cout << sum(10, 7) << std::endl;   // 17

Să analizăm un alt exemplu:

#include <iostream>
 
int calculate(int, int, char);
 
int main()
{
    std::cout << calculate(10, 6, '+') << std::endl;   // 16
    std::cout << calculate(10, 6, '-') << std::endl;   // 4
    std::cout << calculate(10, 6, '*') << std::endl;   // 60
    std::cout << calculate(10, 6, '/') << std::endl;   // 0
}
 
int calculate(int n, int m, char op)
{
    switch(op)
    {
        case '+': return n + m;
        case '-': return n - m;
        case '*': return n * m;
        default: return 0;
    }
}

Aici este definită funcția calculate, care primește două numere și un caracter – simbolul operației. În instrucțiunea switch, în funcție de simbol, se returnează rezultatul operației corespunzătoare folosind return.

return fără valoare

Cealaltă formă a operatorului return nu are nicio valoare după el și poate fi utilizată în funcțiile care nu returnează nimic, adică cele cu tipul de întoarcere void. Este util dacă dorim să ieșim din funcție mai devreme.

De exemplu, o funcție primește numele și vârsta utilizatorului și le afișează:

#include <iostream>
#include <string>
 
void print(std::string, unsigned);
 
int main()
{
    print("Tom", 38);       // Name: Tom       Age: 38
    print("Bob", 2500);     // Incorrect age
}
 
void print(std::string name, unsigned age)
{
    if(age > 120)
    {
        std::cout << "Incorrect age" << std::endl;
        return; // ieșim din funcție
    }

    std::cout << "Name: " << name << "\tAge: " << age << std::endl;
}

Aici, în funcția print, verificăm vârsta transmisă. Dacă este un număr nepermis, ieșim din funcție cu return.

Deducerea tipului rezultatului

Compilatorul C++ poate deduce automat tipul valorii returnate dacă, în locul tipului explicit, folosim auto:

#include <iostream>
 
auto sum(int a, int b)
{
    return a + b;
}
 
int main()
{
    std::cout << sum(3, 6) << std::endl; // 9
}

Aici tipul rezultatului este dedus automat. Deoarece a + b este un int, compilatorul stabilește că funcția returnează un int.

În acest caz nu există un avantaj real în utilizarea lui auto în loc de int. De obicei, auto este util când tipul returnat este lung sau complex și ajută la scurtarea codului.