One of the typical usage of the references is returning from function by reference rather than by value. Returning reference often more effective than copying. In some cases, however, copying is a must.

template <typename T>
class matrix
{
public:
    // ...
          T& operator()(int i, int j)       { return v[i*cols+j]; }
    const T& operator()(int i, int j) const { return v[i*cols+j]; }

    matrix& operator+=( const matrix& other)
    {
        for (int i = 0; i < cols*rows; ++i)
            v[i] += other.v[i];
    }
private:
    // ...
    T* v;
};

template <typename T>
matrix<T> operator+( const matrix<T>& left, const matrix<T>& right)
{
    matrix<T> result(left);
    result += right;

    return result;
}

Let us discover the return values one-by-one:

    T& operator()(int i, int j)  { return v[i*cols+j]; }

This function returns reference to the selected value, allowing clients to modify the appropriate element of the matrix:

    matrix<double> dm(10,20);
    // ...
    dm(2,3) = 3.14;  // modify metrix element
    cout << dm(2,3); // copies matrix element
    dm(2,3) += 1.1;  // modify matrix element

    double& dr = dm(2,3);   // doesn't copies
    dr += 1.1;              // modify matrix element

A second version of operator() is presented to read constant matrices.

  const T& operator()(int i, int j) const { return v[i*cols+j]; }

This const memberfunction must return const reference, otherwise the const-correctness would be leaking:

    const matrix<double> cm = dm;
    // ...
    cm(2,3) = 3.14;  // syntax error: returns with const reference
    cout << cm(2,3); // ok: copies (read) matrix element
    cm(2,3) += 1.1;  // syntax error: returns with const reference

    double& dr = cm(2,3);   // syntax error: const reference
                            // does not convert to reference
    const double& cdr = cm(2,3);    // ok, doesn't copy  

Most assignment operators defined with (non-const) reference type as return value:

    matrix& operator=(const matrix& other);

    matrix& operator+=( const matrix& other)
    {
        for (int i = 0; i < cols*rows; ++i)
            v[i] += other.v[i];
    }

This is more effective than a value returning type, and also avoiding unneccessary restrictions:

    dm1 = dm2 = dm3;

    ++( dm1 += dm2 );

In the previous examples returning reference (or constant reference) was safe, because the memory area which was referred survived the operation. In the next addiotion returning a reference (or constant reference) would be a major fault:

template <typename T>
matrix<T> operator+( const matrix<T>& left, const matrix<T>& right)
{
    matrix<T> result(left);     // local variable: automatic storage
    result += rigth;

    return result;      // result will disappear: must copy
}