14.7. Почленное присваивание A

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

newAcct = oldAcct;

по умолчанию присваивает каждому нестатическому члену newAcct значение соответственного члена oldAcct. Компилятор генерирует следующий копирующий

inline Account& Account::

operator=( const Account &rhs )

{

_name = rhs._name; _balance = rhs._balance; _acct_nmbr =

rhs._acct_nmbr;

оператор присваивания:

}

Как правило, если для класса не подходит почленная инициализация по умолчанию, то не подходит и почленное присваивание по умолчанию. Например, для первоначального определения класса Account, где член _name был объявлен как char*, такое присваивание не годится ни для _name, ни для _acct_nmbr.

Мы можем подавить его, если предоставим явный копирующий оператор присваивания,

// общий вид копирующего оператора присваивания className&

className::

operator=( const className &rhs )

{

// не надо присваивать самому себе if ( this != &rhs )

{

// здесь реализуется семантика копирования класса

}

// вернуть объект, которому присвоено значение return *this;

где будет реализована подходящая для класса семантика:

}

Здесь условная инструкция

if ( this != &rhs )

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

ресурс, ассоциированный с объектом в левой части, чтобы назначить вместо него ресурс, ассоциированный с объектом в правой части. Рассмотрим копирующий оператор

Account&

Account::

operator=( const Account &rhs )

{

// не надо присваивать самому себе if ( this != &rhs )

{

delete [] _name;

_name = new char[strlen(rhs._name) +1];

strcpy( _name,rhs._name ); _balance = rhs._balance; _acct_nmbr = rhs._acct_nmbr;

}

return *this;

присваивания для класса Account:

}

Когда один объект класса присваивается другому, как, например, в инструкции:

newAcct = oldAcct;

выполняются следующие шаги:

1.Выясняется, есть ли в классе явный копирующий оператор присваивания.

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

вданном месте программы.

3.Оператор вызывается для выполнения присваивания; если же он недоступен, компилятор выдает сообщение об ошибке.

4.Если явного оператора нет, выполняется почленное присваивание по умолчанию.

5.При почленном присваивании каждому члену встроенного или составного члена объекта в левой части присваивается значение соответственного члена объекта в правой части.

6.Для каждого члена, являющегося объектом класса, рекурсивно применяются шаги 1-6, пока не останутся только члены встроенных и составных типов.

Если мы снова модифицируем определение класса Account так, что _name будет иметь тип string, то почленное присваивание по умолчанию

newAcct = oldAcct;

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

inline Account& Account::

operator=( const Account &rhs )

{

_balance = rhs._balance; _acct_nmbr = rhs._acct_nmbr;

// этот вызов правилен и с точки зрения программиста

name.string::operator=( rhs._name );

}

Однако почленное присваивание по умолчанию для объектов класса Account не подходит из-за _acct_nmbr. Нужно реализовать явный копирующий оператор

Account&

Account::

operator=( const Account &rhs )

{

// не надо присваивать самому себе if ( this != &rhs )

{

// вызывается string::operator=( const string& )

_name = rhs._name; _balance = rhs._balance;

}

return *this;

присваивания с учетом того, что _name – это объект класса string:

}

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

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

Упражнение 14.17

Реализуйте копирующий оператор присваивания для каждого из классов, определенных в упражнении 14.14 из раздела 14.6.

Упражнение 14.18

Нужен ли копирующий оператор присваивания для того класса, который вы выбрали в упражнении 14.3 из раздела 14.2? Если да, реализуйте его. В противном случае объясните, почему он не нужен.

14.8. Соображения эффективности A

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

bool sufficient_funds( Account acct, double );

//более эффективно, но после возврата адрес оказывается недействительным

//это может привести к краху программы

Matrix&

operator+( const Matrix& m1, const Matrix& m2 )

{

Matrix result;

// выполнить сложение ...

return result;

}

но при этом происходят частые сбои программы. Дело в том, что значение переменной result не определено после выхода из функции, в которой она объявлена. (Мы возвращаем ссылку на локальный объект, который после возврата не существует.)

Значение возвращаемого адреса должно оставаться действительным после выхода из

//нет возможности гарантировать отсутствие утечки памяти

//поскольку матрица может быть большой, утечки будут весьма заметными

Matrix&

operator+( const Matrix& m1, const Matrix& m2 )

{

Matrix *result = new Matrix; // выполнить сложение ...

return *result;

функции. В приведенной реализации возвращаемый адрес не затирается:

}

Однако это неприемлемо: происходит большая утечка памяти, так как ни одна из частей программы не отвечает за применение оператора delete к объекту по окончании его использования.

Вместо оператора сложения лучше применять именованную функцию, которой в

//это обеспечивает нужную эффективность,

//но не является интуитивно понятным для

пользователя

void

mat_add( Matrix &result,

const Matrix& m1, const Matrix& m3 )

{

// вычислить результат

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

}

Таким образом, проблема производительности решается, но для класса уже нельзя использовать операторный синтаксис, так что теряется возможность инициализировать объекты

// более не поддерживается

Matrix c = a + b;

// тоже не

поддерживаетс

я

и использовать их в выражениях:

if ( a + b > c ) ...

Неэффективный возврат объекта класса – слабое место С++. В качестве одного из

Matrix&

operator+( const Matrix& m1, const Matrix& m2 )

name result

{

Matrix result; // ...

return result;

решений предлагалось расширить язык, введя имя возвращаемого функцией объекта:

}

Тогда компилятор мог бы самостоятельно переписать функцию, добавив к ней третий

//переписанная компилятором функция

//в случае принятия предлагавшегося расширения языка

void

operator+( Matrix &result, const Matrix& m1, const Matrix& m2 )

name result

{

// вычислить результат

параметр-ссылку:

}

и преобразовать все вызовы этой функции, разместив результат непосредственно в области, на которую ссылается первый параметр. Например:

Matrix c = a + b;

Matrix c;

было бы трансформировано в

operator+(c, a, b);

Это расширение так и не стало частью языка, но предложенная оптимизация прижилась. Компилятор в состоянии распознать, что возвращается объект класса и выполнить трансформацию его значения и без явного расширения языка. Если дана функция общего

classType

functionName( paramList )

{

classType namedResult; // выполнить какие-то

действия ...

return namedResult;

вида:

}

то компилятор самостоятельно трансформирует как саму функцию, так и все обращения

void

functionName( classType &namedResult, paramList )

{

// вычислить результат и разместить его по адресу namedResult

к ней:

}

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

И последнее замечание об эффективности работы с объектами в C++. Инициализация объекта класса вида

Matrix c = a + b;

всегда эффективнее присваивания. Например, результат следующих двух инструкций

Matrix c;

такой же, как и в предыдущем случае: c = a + b;

for ( int ix = 0; ix < size-2; ++ix ) { Matrix matSum = mat[ix] + mat[ix

+1]; // ...

но объем требуемых вычислений значительно больше. Аналогично эффективнее писать:

}

чем