Parametri constanți

Parametrii pot fi constanți – valorile acestor parametri nu pot fi modificate. Parametrii constanți sunt precedați de cuvântul cheie const. De exemplu:

#include <iostream>
  
void square(int);
  
int main()
{
    int number {4};
    square(number);   // n * n = 16
}
void square(const int n)
{
    //n = n * n;     nu este permis
    std::cout << "n * n = " << n * n << std::endl;  
}

Aici, în funcția square, parametrul n este definit ca fiind constant. În interiorul funcției square, nu putem modifica valoarea lui. Practic, acesta se comportă ca o constantă.

Este important de menționat că const se utilizează pentru parametri constanți doar în definirea funcției:

void square(const int n) { ...

În prototipul funcției, pentru parametrii transmiși prin valoare, nu este obligatoriu să folosim const:

// ambele variante sunt valide
void square(int);
void square(const int);

Însă pentru parametrii transmiși prin referință, indicarea lui const în prototip este obligatorie dacă vrem ca referința să fie constantă.

De ce sunt utili parametrii constanți?

Uneori e necesar să garantăm că un parametru va avea aceeași valoare pe întreaga durată a execuției funcției. Dacă parametrul nu este constant, e posibil să fie modificat din greșeală în corpul funcției. De aceea, se recomandă ca parametrii care nu trebuie modificați să fie declarați imediat ca const.

Unui parametru constant i se poate transmite atât o constantă, cât și o variabilă.

Această situație trebuie deosebită de transmiterea constantelor ca argumente pentru parametri neconstanți:

#include <iostream>
 
void square(int, int);
 
int main()
{
    const int a = 4;
    const int b = 5;
    square(a, b);   // 400
    return 0;
}
void square(int a, int b)
{
    a = a * a;
    b = b * b;
    std::cout << "In square: a * b = " << a * b << std::endl;
}

Chiar dacă funcției i se transmit constante, din moment ce parametrii a și b nu sunt declarați ca const, funcția le poate modifica valorile.

Referințe constante

Parametrii transmiși prin referință pot fi, de asemenea, constanți:

#include <iostream>
  
void square(const int&);    // funcția primește o referință constantă
  
int main()
{
    int number = 5;
    square(number);  // n * n = 25
}
void square(const int &n)
{
    // n = n * n;     nu este permis
    std::cout << "n * n = " << n * n << std::endl;
}

Valoarea unei referințe constante nu poate fi modificată.

Dacă o funcție primește argumente prin referință și vrem să îi transmitem o constantă, atunci parametrul trebuie să fie și el o referință la constantă (nu putem transmite o constantă unei referințe neconstante):

#include <iostream>
  
void square(const int&);
  
int main()
{
    const int number {6};
    square(number);  // n * n = 36
}
void square(const int &n)
{
    std::cout << "n * n = " << n * n << std::endl;
}

Când trebuie să transmitem în funcție obiecte mari, care nu trebuie modificate, utilizarea referințelor constante este alegerea optimă.