Argomenti della funzione tipo-riferimento

È spesso più efficiente passare alle funzioni riferimenti anziché oggetti di grandi dimensioni. In questo modo il compilatore può passare l'indirizzo dell'oggetto rispettando la sintassi che sarebbe stata usata per accedere all'oggetto. Si consideri l'esempio seguente che usa la struttura 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;
}

Il codice precedente mostra che i membri di una struttura passata per riferimento sono accessibili usando l'operatore member-selection (.) anziché l'operatore di selezione dei membri del puntatore (->).

Sebbene gli argomenti passati come tipi di riferimento osservino la sintassi dei tipi non puntatore, mantengono una caratteristica importante dei tipi di puntatore: sono modificabili a meno che non siano dichiarati come const. Poiché lo scopo del codice precedente non è quello di modificare l'oggetto date, un prototipo di funzione più appropriato è il seguente:

long DateOfYear( const Date& date );

Questo prototipo garantisce che la funzione DateOfYear non modificherà il relativo argomento.

Qualsiasi funzione prototipo come tipo riferimento può accettare un oggetto dello stesso tipo al suo posto perché esiste una conversione standard da typename a typename&.

Vedi anche

Riferimenti