Parametrii funcției

Prin intermediul parametrilor se pot transmite diverse valori către o funcție. Parametrii sunt enumerați după numele funcției, între paranteze, separați prin virgulă:

(typ_parametru1 nume_parametru1, typ_parametru2 nume_parametru2, ... typ_parametruN nume_parametruN)

Pentru fiecare parametru se specifică tipul și numele acestuia.

De exemplu, să definim și să apelăm o funcție care afișează în consolă numele și vârsta unei persoane:

#include <iostream>
  
void print(std::string name, unsigned age)
{
    std::cout << "Name: " << name << "\tAge: " << age << std::endl;
}
  
int main()
{
    print("Tom", 38);    // Name: Tom    Age: 38
}

La rularea programului vom obține următoarea ieșire în consolă:

Name: Tom    Age: 38

Funcția print() primește doi parametri și afișează valorile acestora. Primul parametru se numește name și este de tip std::string. Al doilea parametru se numește age și este de tip unsigned int. La apelul funcției trebuie transmise valori pentru acești parametri:

print("Tom", 38);

Valorile transmise parametrilor funcției la apelare se numesc argumente. În acest caz sunt transmise un literal de tip șir de caractere și un literal întreg. Argumentele se transmit prin poziție: primul argument ("Tom") este asociat primului parametru (name), iar al doilea (38) celui de-al doilea parametru (age).

Argumentele trebuie să corespundă ca tip parametrilor sau să permită conversia implicită către tipul parametrului. În exemplul de mai sus, literalul șirului este convertit automat în std::string.

În mod similar, se pot transmite nu doar literali, ci și valori ale variabilelor sau constante:

#include <iostream>
  
void print(std::string name, unsigned age)
{
    std::cout << "Name: " << name << "\tAge: " << age << std::endl;
}
  
int main()
{
    const std::string userName {"Bob"};
    unsigned userAge {42};
    print(userName, userAge);    // Name: Bob    Age: 42 
}

La apelul funcției, parametrul name va primi valoarea constantei userName, iar parametrul age valoarea variabilei userAge.

Când folosim un prototip al funcției, acesta trebuie să conțină tipurile parametrilor:

#include <iostream>
  
void print(std::string, unsigned);  // prototipul funcției print
  
int main()
{
    print("Sam", 28);    // Name: Sam    Age: 28
}
 
void print(std::string name, unsigned age)
{
    std::cout << "Name: " << name << "\tAge: " << age << std::endl;
}

Opțional, în prototip pot fi menționate și numele parametrilor:

void print(std::string name, unsigned age);  // prototip

Argumente implicite

O funcție poate primi argumente implicite, adică valori pe care le va folosi dacă, la apelul funcției, nu sunt transmise explicit:

#include <iostream>
 
void print(std::string name, unsigned age = 18)
{
    std::cout << "Name: " << name << "\tAge: " << age << std::endl;
}
  
int main()
{
    print("Sam");       // Name: Sam    Age: 18
    print("Tom", 22);   // Name: Tom    Age: 22
}

Pentru a seta o valoare implicită, aceasta se atribuie în declarația parametrului: unsigned age = 18. Dacă nu se transmite o valoare pentru al doilea parametru, se va folosi cea implicită. Ieșirea în consolă:

Name: Sam       Age: 18  
Name: Tom       Age: 22

Dacă funcția are un prototip, acesta poate conține și valorile implicite, iar în definiția funcției ele nu mai sunt necesare:

#include <iostream>
  
void print(std::string, unsigned = 18);  // prototip
  
int main()
{
    print("Sam");       // Name: Sam    Age: 18
    print("Tom", 23);   // Name: Tom    Age: 23
}
 
void print(std::string name, unsigned age)
{
    std::cout << "Name: " << name << "\tAge: " << age << std::endl;
}

La definirea parametrilor opționali, aceștia trebuie să urmeze după cei obligatorii. De exemplu, să setăm și pentru name o valoare implicită:

#include <iostream>
  
void print(std::string = "Undefined", unsigned = 18);  // prototip
  
int main()
{
    print();            // Name: Undefined  Age: 18
    print("Sam");       // Name: Sam    Age: 18
    print("Tom", 23);   // Name: Tom    Age: 23
}
 
void print(std::string name, unsigned age)
{
    std::cout << "Name: " << name << "\tAge: " << age << std::endl;
}

Deoarece name este acum parametru opțional, parametrul age care îl urmează trebuie și el să aibă o valoare implicită.

Deducerea automată a tipului parametrilor

Începând cu C++20, se poate folosi cuvântul cheie auto în locul unui tip concret pentru parametri. Tipul va fi dedus automat în timpul compilării, în funcție de argumentele transmise:

#include <iostream>
 
void sum(auto, auto);   // prototipul funcției sum
 
int main()
{
    const int n1{3};
    const int n2{4};
    sum(n1, n2);  // 3 + 4 = 7
 
    const double d1{3.3};
    const double d2{4.4};
    sum(d1, d2);  // 3.3 + 4.4 = 7.7
}
 
void sum(auto a, auto b)
{
    auto result = a + b;
    std::cout << a << " + " << b << " = " << result << std::endl;
}

În acest caz, funcția sum calculează suma a două valori. Deoarece putem transmite numere de tipuri diferite, folosirea cuvântului auto permite ca tipul să fie dedus automat, evitând specificarea explicită.