 |
Перегрузка операции присваивания
|
|
|
|
Операция отличается тремя особенностями:
· операция не наследуется;
· операция определена по умолчанию для каждого класса в качестве операции поразрядного копирования объекта, стоящего справа от знака операции, в объект, стоящий слева.
· операция может перегружаться только в области определения класса. Это гарантирует, что первым операндом всегда будет леводопустимое выражение.
Если вас устраивает поразрядное копирование, нет смысла создавать собственную функцию operator=(). Однако бывают случаи, когда поразрядное копирование нежелательно. Например, использование предопределенной операции присваивания для классов, содержащих указатели в качестве компонентных данных, чаще всего приводит к ошибкам. Покажем это на примере.
Пользовательский класс - строка string:
class string
{
char *p; //указатель на строку
int len; //текущая длина строки
public:
string(char *);
~string();
void show();
};
string::string(char*ptr)
{len=strlen(ptr);
p=new chat[len+1];
if(!p){cout<<”Ошибка выделения памяти\n”);
exit(1);}
strcpy(p,ptr);}
string::~string()
{delete[]p;}
void string::show()
{cout<<*p<<”\n”;}
void main()
string s1(“Это первая строка”),
s2(“А это вторая строка”);
s1.show; s2.show;
s2=s1; // Это ошибка
s1.show; s2.show;
}
В чем здесь ошибка? Когда объект s1 присваивается объекту s2, указатель p объекта s2 начинает указывать на ту же самую область памяти, что и указатель p объекта s1. Таким образом, когда эти объекты удаляются, память, на которую указывает указатель p объекта s1, освобождается дважды, а память, на которую до присваивания указывал указатель p объекта s2, не освобождается вообще.
Хотя в данном примере эта ошибка и неопасна, в реальных программах с динамическим распределением памяти она может вызвать крах программы.
|
|
|
В этом случае необходимо самим перегружать операцию присваивания. Покажем, как это сделать для нашего класса string.
class string
{
char *p; //указатель на строку
int len; //текущая длина строки
public:
...
string& operator=(string&);
};
string& string::operator=(string& ob);
{if(this==&ob) return *this;
if(len<ob.len){
//требуется выделить дополнительную память
delete[]p;
p=new char[ob.len+1];
if(!p){cout<<”Ошибка выделения памяти\n”);
exit(1);}
len=ob.len;
strcpy(p,ob.p);
return *this;}
В этом примере выясняется, не происходит ли самоприсваивание(типа ob=ob). Если имеет место самоприсваивание, то просто возвращается ссылка на объект.
Затем проверяется, достаточно ли памяти в объекте, стоящем слева от знака присваивания, для объекта, стоящего справа от знака присваивания. Если не достаточно, то память освобождается и выделяется новая, требуемого размера. Затем строка копируется в эту память.
Отметим две важные особенности функции operanor=. Во-первых, в ней используется параметр-ссылка. Это необходимо для предотвращения создания копии объекта, передаваемого через параметр по значению. В случае создания копии она удаляется вызовом деструктора при завершении работы функции. Но деструктор освобождает память, на которую указывает р. Однако эта память все еще необходима объекту, который является аргументом. Параметр-ссылка помогает решить эту проблему.
Во-вторых, функция operator=() возвращает не объект, а ссылку на него. Смысл этого тот же, что и при использовании параметра-ссылки. Функция возвращает временный объект, который удаляется после завершения ее работы. Это означает, что для временной переменной будет вызван деструктор, который освобождает память по адресу р. Но она необходима для присваивания значения объекту. Поэтому, чтобы избежать создания временного объекта, в качестве возвращаемого значения используется ссылка.
Другой путь решения проблем, описанных выше–это создание конструктора копирования. Но конструктор копирования может оказаться не столь эффективным решением, как ссылка в качестве параметра и ссылка в качестве возвращаемого значения функции. Это происходит потому, что использование ссылки исключает затраты ресурсов, связанных с копированием объектов в каждом из двух указанных случаев.
|
|
|
Перегрузка операции new
Операция new, заданная по умолчанию, может быть в двух формах:
1) new тип <инициализирующее выражение>
2) new тип[];
Первая форма используется не для массивов, вторая–для массивов.
Перегруженную операцию new можно определить в следующих формах, соответственно для не массивов и для массивов:
void* operator new(size_t t[,остальные аргументы]);
void* operator new[](size_t t[,остальные аргументы]);
Первый и единственный обязательный аргумент t всегда должен иметь тип size_t. Если аргумент имеет тип size_t, то в операцию-функцию new автоматически подставляется аргумент sizeof(t), т.е. она получает значение, равное размеру объекта t в байтах.
Например, пусть задана следующая функция:
void* operator new(size_t t,int n){return new char[t*n];}
и она вызывается следующим образом:
double *d=new(5)double;
Здесь t=double, n=5.
В результате после вызова значение t в теле функции будет равно sizeof(double).
При перегрузке операции new появляется несколько глобальных операций new, одна из которых определена в самом языке по умолчанию, а другие являются перегруженными. Возникает вопрос: как различить такие операции? Это делается путем изменения числа и типов их аргументов. При изменении только типов аргументов может возникнуть неоднозначность, являющаяся следствием возможных преобразований этих типов друг к другу. При возникновении такой неоднозначности следует при обращении к new задать тип явно, например:
new((double)5)double;
Одна из причин, по которой перегружается операция new, состоит в стремлении придать ей дополнительную семантику, например, обеспечение диагностической информацией или устойчивости к сбоям. Кроме того, класс может обеспечить более эффективную схему распределения памяти, чем та, которую предоставляет система.
В соответствии со стандартом С++ в заголовочном файле <new> определены следующие функции-операции new, позволяющие передавать наряду с обязательным первым size_t аргументом и другие.
|
|
|
void* operatop new(size_t t)throw(bad_alloc);
void* operatop new(size_t t,void* p)throw();
void* operatop new(size_t t,const nothrow&)throw();
void* operatop new(size_t t,allocator& a);
void* operatop new[](size_t t)throw(bad_alloc);
void* operatop new[](size_t t,void* p)throw();
void* operatop new[](size_t t,const nothrow&)throw();
Эти функции используют генерацию исключений(throw) и собственный распределитель памяти(allocator).
Версия с nothrow выделяет память как обычно, но если выделение заканчивается неудачей, возвращается 0, а не генерируется bad_alloc. Это позволяет нам для выделения памяти использовать стратегию обработки ошибок до генерации исключения.
|
|
|
