10.6 Ссылки

Ссылка – это еще одно имя переменной. Если имеется какая-либо переменная, например

Complex x;

то можно определить ссылку на переменную x как

Complex& y = x;

и тогда x и y обозначают одну и ту же величину. Если выполнены операторы

x.real = 1;

x.imaginary = 2;

то y.real равно 1 и y.imaginary равно 2. Фактически, ссылка – это адрес переменной (поэтому при определении ссылки используется символ & -- знак операции взятия адреса), и в этом смысле она сходна с указателем, однако у ссылок есть свои особенности.

Во-первых, определяя переменную типа ссылки, ее необходимо инициализировать, указав, на какую переменную она ссылается. Нельзя определить ссылку

int& xref;

можно только

int& xref = x;

Во-вторых, нельзя переопределить ссылку, т.е. изменить на какой объект она ссылается. Если после определения ссылки xref мы выполним присваивание

xref = y;

то выполнится присваивание значения переменной y той переменной, на которую ссылается xref. Ссылка xref по-прежнему будет ссылаться на x. В результате выполнения следующего фрагмента программы:

int x = 10;

int y = 20;

int& xref = x;

xref = y;

x += 2;

cout << "x = " << x << endl;

cout << "y = " << y << endl;

cout << "xref = " << xref << endl;

будет выведено:

x = 22

y = 20

xref = 22

В-третьих, синтаксически обращение к ссылке аналогично обращению к переменной. Если для обращения к атрибуту объекта, на который ссылается указатель, применяется операция ->, то для подобной же операции со ссылкой применяется точка ".".

Complex a;

Complex* aptr = &a;

Complex& aref = a;

aptr->real = 1;

aref.imaginary = 2;

Как и указатель, ссылка сама по себе не имеет значения. Ссылка должна на что-то ссылаться, тогда как указатель должен на что-то указывать.

10.6 Распределение памяти при передаче аргументов функции

Рассказывая о функциях, мы отметили, что у функций (как и у методов классов) есть аргументы, фактические значения которых передаются при вызове функции.

Рассмотрим более подробно метод Add класса Complex. Изменим его немного, так, чтобы он вместо изменения состояния объекта возвращал результат операции сложения:

Complex

Complex::Add(Complex x)

{

Complex result;

result.real = real + x.real;

result.imaginary = imaginary + x.imaginary;

return result;

}

При вызове этого метода

Complex n1;

Complex n2;

. . .

Complex n3 = n1.Add(n2);

значение переменной n2 передается в качестве аргумента. Компилятор создает временную переменную типа Complex, копирует в нее значение n2 и передает эту переменную в метод Add. Такая передача аргумента называется передачей по значению. У передачи аргументов по значению имеется два свойства. Во-первых, эта операция не очень эффективна, особенно если объект сложный и требует большого объема памяти или же если создание объекта сопряжено с выполнением сложных действий (о конструкторах объектов будет рассказано в лекции 12). Во-вторых, изменения аргумента функции не сохраняются. Если бы метод Add был бы определен как

Complex

Complex::Add(Complex x)

{

Complex result;

x.imaginary = 0;

// изменение аргумента метода

result.real = real + x.real;

result.imaginary = imaginary + x.imaginary;

return result;

}

то при вызове n3 = n1.Add(n2) результат был бы, конечно, другой, но значение переменной n2 не изменилось бы. Хотя в данном примере изменяется значение аргумента метода Add, этот аргумент – лишь копия объекта n2, а не сам объект. По завершении выполнения метода Add его аргументы просто уничтожаются, и первоначальные значения фактических параметров сохраняются.

При возврате результата функции выполняются те же действия, т.е. создается временная переменная, в которую копируется результат, и уже затем значение временной переменной копируется в переменную n3. Временные переменные потому и называют временными, что компилятор сам создает их на время выполнения метода и сам их уничтожает.

Другим способом передачи аргументов является передача по ссылке. Если изменить описание метода Add на

Complex

Complex::Add(Complex& x)

{

Complex result;

result.real = real + x.real;

result.imaginary = imaginary + x.imaginary;

return result;

}

то при вызове n3 = n1.Add(n2) компилятор будет создавать ссылку на переменную n2 и передавать ее методу Add. В большинстве случаев это намного эффективнее, так как для ссылки требуется немного памяти и создать ее проще. Однако мы получим нежелательный в данном случае эффект. Метод

Complex

Complex::Add(Complex& x)

{

Complex result;

x.imaginary = 0; // изменение значения

// по переданной ссылке

result.real = real + x.real;

result.imaginary = imaginary + x.imaginary;

return result;

}

изменит значение переменной n2. Операция Add не предусматривает изменения собственных операндов. Чтобы избежать ошибок, лучше записать аргумент с описателем const, который определяет соответствующую переменную как неизменяемую.

Complex::Add(const Complex& x)

В таком случае попытка изменить значение аргумента будет обнаружена на этапе компиляции, и компилятор выдаст ошибку. Передачей аргумента по неконстантной ссылке можно воспользоваться в том случае, когда функция действительно должна изменить свой аргумент. Например, метод Coord класса Figure записывает координаты некой фигуры в свои аргументы:

void

Figure::Coord(int& x, int& y)

{

x = coordx;

y = coordy;

}

При вызове

int cx, cy;

Figure fig;

. . .

fig.Coord(cx, cy);

переменным cx и cy будет присвоено значение координат фигуры fig.

Вернемся к методу Add и попытаемся оптимизировать передачу вычисленного значения. Простое на первый взгляд решение возвращать ссылку на результат не работает:

Complex&

Complex::Add(const Complex& x)

{

Complex result;

result.real = real + x.real;

result.imaginary = imaginary + x.imaginary;

return result;

}

При выходе из метода автоматическая переменная result уничтожается, и память, выделенная для нее, освобождается. Поэтому результат Add – ссылка на несуществующую память. Результат подобных действий непредсказуем. Иногда программа будет работать как ни в чем не бывало, иногда может произойти сбой, иногда результат будет испорчен. Однако возвращение результата по ссылке возможно, если объект, на который эта ссылка ссылается, не уничтожается после выхода из функции или метода. Если метод Add прибавляет значение аргумента к текущему значению объекта и возвращает новое значение в качестве результата, то его можно записать:

Complex&

Complex::Add(const Complex& x)

{

real += x.real;

imaginary += x.imaginary;

return *this;

// передать ссылку на текущий объект

}

Как и в случае с аргументом, передача ссылки на текущий объект позволяет использовать метод Add слева от операции присваивания, например в следующем выражении:

x.Add(y) = z;

К значению объекта x прибавляется значение y, а затем результату присваивается значение z (фактически это эквивалентно x = z). Чтобы запретить подобные конструкции, достаточно добавить описатель const перед типом возвращаемого значения:

const Complex&

Complex::Add(const Complex& x)

. . .

Передача аргументов и результата по ссылке аналогична передаче указателя в качестве аргумента:

Complex*

Complex::Add(Complex* x)

{

real += x->real;

imaginary += x->imaginary;

return this;

}

Если нет особых оснований использовать в качестве аргумента или результата именно указатель, передача по ссылке предпочтительней. Во-первых, проще запись операций, а во-вторых, обращения по ссылке легче контролировать.