|
43
Разумеется, та же проблема возникает и при создании копий. Конструктор копий по умолчанию
копирует указатель, а не данные, на которые он ссылается. По этой причине конструктор копий и
оператор
=
обычно перегружаются одновременно.
Присваивание и инициализация
Мы уже обсуждали, чем инициализация отличается от присваивания, но эта тема настолько важна, что
я повторю еще раз. Если объект слева от оператора
=
был сконструирован заранее,
=
означает
присваивание. Если в этом выражении он конструируется впервые, речь идет о конструировании и
конструкторах. В следующем примере первая строка с символом
=
выполняет инициализацию и
вызывает конструктор копий. Вторая строка выполняет присваивание и вызывает оператор
=
.
Foo f;
Foo f1 = f;
// Инициализация; f1 еще не существует
f1 = f;
// Присваивание: объект f1 уже сконструирован
Присваивание по умолчанию
Оператор
=
по умолчанию, как и конструктор копий по умолчанию, ведет себя четко определенным
образом. Как и конструктор копий, который рекурсивно вызывает другие конструкторы копий,
оператор
=
по умолчанию не ограничивается простым копированием битов из одного объекта в другой.
Последовательность его действий выглядит так:
1. Присваивание для базовых классов выполняется в порядке их перечисления в списке
наследования. При этом используются перегруженные операторы
=
базовых классов или в
случае их отсутствия — оператор
=
по умолчанию.
2. Присваивание переменных класса выполняется в порядке их перечисления в объявлении
класса. При этом используются перегруженные операторы
=
базовых классов или в случае их
отсутствия — оператор
=
по умолчанию.
Эти правила применяются рекурсивно. Как и в случае с конструкторами, сначала выполняется
присваивание для первого базового класса первого базового класса и т. д.
Перегрузка оператора =
Перегрузка оператора
=
практически не отличается от перегрузки всех остальных операторов. Пока нас
интересует сигнатура оператора
=
, которая выглядит так:
Х& X::operator=(const X&)
.
class String {
private:
char*
s;
public:
String(char*);
~String();
String(const
String&);
//
Возможно, тоже решает проблему
String& operator=(const String&);
void Dump(ostream& os);
};
String::String(char* s) : s(NULL)
{
if (str == NULL) {
// NULL означает пустую строку
s = new char[1];
*s = ‘\0’;
}
else
{
s = new char[strlen(str) + 1];
strcpy(s,
str);
44
}
}
String::~String()
{
delete
s;
}
String::String(const String& s1) : s(NULL)
{
s = new char[strlen(s1.s) + 1];
strcpy(s,
s1.s);
}
String& String::operator=(const String& s1)
{
if (this == &s1) return *this;
delete
s;
//
Уничтожить предыдущее значение
s = new char[strlen(s1.s) + 1];
strcpy(s,
s1.s);
return
*this;
}
void String::Dump(ostream& os)
{
os << “\”” << s << “\””;
}
Конструктор копий и оператор
=
вместо простого копирования адреса теперь создают копию новой
строки. Деструктор стал безопасным, и миру ничего не угрожает.
Ниже показан обобщенный вид оператора
=
, который стоит занести в долговременную память (не
компьютерную, а вашу собственную):
1. Убедитесь, что не выполняется присваивание вида
x=x;
. Если левая и правая части ссылаются
на один объект, делать ничего не надо. Если не перехватить этот особый случай, то следующий
шаг уничтожит значение до того, как оно будет скопировано.
2. Удалите предыдущие данные.
3. Скопируйте значение.
4. Возвратите указатель
*this
.
Оператор
=
возвращает
*this
, чтобы стало возможным вложенное присваивание вида
а=b=с
. В C++,
как и в С, значением этого выражения является присваиваемая величина. Выражение интерпретируется
справа налево, как
а=(b=с)
.
А теперь — плохие новости. Как и в случае с конструкторами копий, при перегрузке оператора
=
C++
умывает руки и отправляется домой. Если вы перегрузили оператор
=
, то на вас ложится
ответственность за выполнение присваивания для переменных и базовых классов; по умолчанию
базовые классы и переменные левостороннего объекта остаются без изменений.
Присваивание для переменных класса
Иногда переменные класса относятся к простейшим типам данных (например,
int
), и тогда
присваивание выполняется с помощью оператора
=
, предоставленного компилятором. Иногда
(например, для класса
String
) их приходится копировать вручную. В остальных случаях переменные
относятся к какому-нибудь нетривиальному классу. Лучший выход из положения — присвоить что-
нибудь таким переменным. При этом компилятор определяет, существует ли для переменной
перегруженный оператор
=
или он должен использовать свой собственный вариант по умолчанию.
class Foo {
Do'stlaringiz bilan baham: |
