Arguments de fonction de type référence

Il est souvent plus efficace de passer des références que de grands objets à des fonctions. Cela permet au compilateur de passer l'adresse de l'objet tout en maintenant la syntaxe qui aurait été utilisée pour accéder à l'objet. Prenons l'exemple suivant, qui utilise la structure Date :

// reference_type_function_arguments.cpp
#include <iostream>

struct Date
{
    short Month;
    short Day;
    short Year;
};

// Create a date of the form DDDYYYY (day of year, year)
// from a Date.
long DateOfYear( Date& date )
{
    static int cDaysInMonth[] = {
        31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
    };
    long dateOfYear = 0;

    // Add in days for months already elapsed.
    for ( int i = 0; i < date.Month - 1; ++i )
        dateOfYear += cDaysInMonth[i];

    // Add in days for this month.
    dateOfYear += date.Day;

    // Check for leap year.
    if ( date.Month > 2 &&
        (( date.Year % 100 != 0 || date.Year % 400 == 0 ) &&
        date.Year % 4 == 0 ))
        dateOfYear++;

    // Add in year.
    dateOfYear *= 10000;
    dateOfYear += date.Year;

    return dateOfYear;
}

int main()
{
    Date date{ 8, 27, 2018 };
    long dateOfYear = DateOfYear(date);
    std::cout << dateOfYear << std::endl;
}

Le code précédent montre que les membres d’une structure passée par référence sont accessibles à l’aide de l’opérateur de sélection de membre (.) au lieu de l’opérateur de sélection de membre pointeur (->).

Bien que les arguments passés en tant que types de référence observent la syntaxe des types non pointeurs, ils conservent une caractéristique importante des types de pointeur : ils sont modifiables sauf si déclarés comme const. Comme l'objectif du code précédent n'est pas de modifier l'objet date, un prototype de fonction plus approprié est :

long DateOfYear( const Date& date );

Ce prototype garantit que la fonction DateOfYear ne modifiera pas son argument.

Toute fonction prototype comme prenant un type référence peut accepter un objet du même type à sa place, car il existe une conversion standard de typename en typename&.

Voir aussi

Informations de référence