AnsiString Famille::GetName(int i)

}

}

4.9. Перегрузка операторов

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

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

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

Пусть @ некоторый оператор языка, кроме следующих:

. – доступ к элементу класса (точка);

.* - доступ к указателю (точка со зведочкой);

:: - разрешение области видимости (двойное двоеточие);

?: - трехместная условная операция, (вопросительный знак с двоеточием, то же самое, что if - else);

# - указание препроцессору.

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

Тип_результата operator @ (список_параметров)

{

//тело функции

}

Но в том случае, когда перегрузка производится в классе, т.е. функция-оператор является членом класса перегрузка имеет вид

Тип_результата имя_класса::operator @ (список_параметров)

{

//тело функции

}

То есть перегрузка оператора это построение функции с именем из специальных символов без передачи аргументов в явном виде. Перегрузка осуществляется с помощью кдючевого слова operator. Хотя функцию operator @ (список_параметров) можно использовать как обычную функцию. Оба способа будут показана в примере, который мы рассмотрим чуть позже.

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

- Перегрузка не может изменять старшинство и ассоциативность операций;

- Нельзя изменять число операндов операций;

- операция присваивания = может быть использована с любым классом без явной перегрузки.

- По крайней мере один аргумент перегруженного оператора должен принадлежать типу который является классом

- Невозможно создать новый оператор. Все, что можно сделать, - это перегузить существующий оператор.

- Нельзя изменять значение оператора по отношению к встроенным типам, т.е int, double, bool, и т.д.

- Функция-операция (т.е. operator @) должна быть либо членом класса (структуры), либо воспринимать один или несколько аргументов, имеющих тип класса или структуры.

Рассмотрим пример перегрузки операторов в задаче сложения комплексных чисел. В программе перегружены операторы + и +=. Причем показано, что перегрузка возможна для выбранных типов переменных.

//Сложение 2-х комплексных чисел

#include <iostream>

#include <windows>

using namespace std;

struct Complex{double real, imag;}; /* Объявление структуры в

*в которой хранятся вещественная и мнимая части комлексного числа */

//--------------------------------------------------------

//Перегрузка оператора +

/*объявляем функцию аргументами которой являются адреса 2-х структур типа Complex*/

Complex operator+(Complex &a, Complex &b){

Complex c;

c.real=a.real+b.real;

c.imag=a.imag+b.imag;

return c;}

//--------------------------------------------------------

//Перегрузка унарного оператора += для комплексных чисел

void operator +=(Complex &a, Complex &b){

/*эта запись говорит о том, что если встретится инструкция a+=b то нужно сделать следующее */

a.real=a.real+b.real;

a.imag=a.imag+b.imag;

}

//------------------------------------------------------

/* Перегрузка унарного оператора += для действительных чисел

* типа double */

void operator +=(Complex &a, double b){

a.real +=b;

}

//-------------------------------------------------------

//определение функции для вывода комплексных чисел

void showComplex (const Complex &x){

if(x.imag>=0)cout<<x.real<<"+j"<<x.imag<<endl;

else cout<<x.real<<"-j"<<-x.imag<<endl;

}

//--------------------------------------------------------

int main(){

Complex x,y,z1,z2;

x.real=20; x.imag=40;

y.real=30; y.imag=50;

SetConsoleOutputCP(1251);

cout<<"Первое число:"; showComplex(x); //Вывод числа x

cout<<"Второе число:"; showComplex(y); //Вывод числа y

z1=operator+(x,y); //здесь перегрузка используется как функция

cout<<"Определение суммы с помощью функции:"; showComplex(z1);

z2=x+y; //перегруженный оператор используется в операции

cout<<"Определение суммы с помошью оператора:"; showComplex(z2);

z1 +=x; //то же, что operator+=(z1,x);

cout<<"Если добавить первое число к сумме, то получится:"; showComplex(z1);

z2 +=30.0; //то же, что operator+=(z2,30.0);

cout<<"Если добавить число 30 к сумме, то получится:"; showComplex(z2);

int i; cin>>i;

return 0;

}

Вот результат работы программы

В этой программе одна и таже функция перегрузки

Complex operator+(const Complex &a,const Complex &b)

используется по-разному. Один раз как обычная функция, которая вызывается из функции main() с помощью ее имени с указанием аргументов

z1=operator+(x,y);

Второй раз как перегруженный оператор

z2=x+y;

Вызов функции в качестве оператора сложения не вызывает никаких трудностей. Напротив, второй вариант, вероятно, не совсем понятен. Сделаем некоторые пояснения. Встретив знак + для небазового типа Complex компилятор проверяет, не является ли этот оператор перегруженным. С этой целью он ищет функцию, у которой имя содержит ключевое слово operator и указанный знак операции. Если эта функция найдена, то он проверяет соответствие её параметров числу и типам операндов. После этого обеспечивает выполнение написанного кода.

В качестве примера перегрузки в классе рассмотрим перегрузку опрератора массива или, лучше сказать, оператора работы с индексами [ ]. В качестве примера рассмотрим класс предназначенный для хранения строки и числа. Чтобы привлечь ваше внимание пусть это будет имя шпиона и его поядковый идентификационный номер (ПИН). Программа подготовлена для случая когда агент по имени Bond забыл свой номер. Введя свое имя, а точнее фамилию он узнает номер.

#include <iostream>

#include <string>

using namespace std;

const int MAX_LEN=100;

/* Класс для хранения имени шпиона и его ПИНа

* имя хранится в массиве strcpy, а ПИН в переменной типа

* int decoderKey */

class SecretInfo{

int decoderKey;

char codeName[MAX_LEN];

public:

SecretInfo(char *spyName, int spyKey); /*Объявляем конструктор

* с двумя аргументами */

int operator [](const char *spyName); //Перегрузка [] вклассе

}; //Конец класса

//Определение конструктора

/* Данный конструктор осуществляет перезапись аргументов

* в переменные объявленные в классе */

SecretInfo::SecretInfo(char *spyName, int spyKey){

strcpy(codeName, spyName); /* встроенная функция strcpy

* копирует вторую строку в первую */

decoderKey=spyKey;

}

/* Определение перегружаемого оператора */

int SecretInfo::operator[](const char *spyName){

if(!strcmp(codeName, spyName)) /* strcmp функция сравнения строк

* возвращает 0 если строки совпадают

* следует напомнить, что в языке С

* вместо false используется ноль*/

return decoderKey;

else

return 0;

} //конец функции-оператора

/*теперь оператор [] означает ПИН агента*/

//===========================================

int main(void){

SecretInfo agent("Bond",7);

char temp[MAX_LEN];

cout<<"Input Your code name:";

cin>>temp;

if(agent[temp])

cout<<"Your Kode Name"<<agent.operator [](temp);

else

cout<<"Sorry Bond! False Name Code"<<endl;

char z;

cin>>z;

return 0;

}

Пример

#include <iostream>

#include <vector>

#include <string>

#include <cstdlib>

#define EOS -1 //Конец строки(возвращаеться функцией get_word)

using namespace std;

class dict_el{ //Элемент словаря (слово и его позиции)

public:

dict_el():Word(""){}; //Конструсторы

dict_el(string wd):Word(wd){};

~dict_el(){}; //Деструктор

void add_pos(const int i){ //Добавить позицию

this->pos.push_back(i);

};

bool operator==(const string& str){

/* сравнение со строкой для алгоритма find */

return (this->Word == str)? true:false;

}

friend ostream& operator<<(ostream& cout, dict_el& rhs);

/*Вывод слова и его позиций */

private:

string Word; //Хранимое слово

vector<int> pos; //Позиции для хранимого слова

};

ostream& operator<<(ostream& cout, dict_el& rhs){

/*Вывод слова и его позиций*/

cout << rhs.Word << ": ";

vector<int>::iterator i;

for (i = rhs.pos.begin(); i!= rhs.pos.end(); ++i)

cout << *i << " "; //Выводит слово: и его позиции

return cout;

}

int get_word(string& str,string& res){ //получить следующее слово

static int current=0; //текущая позиция

int i;

while(isspace(str[current])) {

++current; //пропустить все знаки пробел,

} //переход строки и т.д.

if (str[current] == '\0') return EOS; //достигнут конец строки

i = current; //начало нового слова

res="";

while(!isspace(str[current]) && str[current]!= '\0'){//считывать слово до конца

res+=tolower(str[current++]); //и записывать его в res

}

return i; //вернуть позицию слова

}

void parse_str(string& str, vector<dict_el>& dict){

/* Разбор строки и формирование словаря */

string temp; //следующее слово

int position; // и его позиция

vector<dict_el>::iterator i;

while((position=get_word(str,temp))!= EOS){ /*Пока не дошли до конца строки получить следующее слово */

i=find(dict.begin(),dict.end(),temp); //искать это слово в словаре

if (i == dict.end()){ //если такого слова нет

dict_el A(temp); //создать его

A.add_pos(position); //ввести первую позицию

dict.push_back(A); //и добать в словарь

}

else{ //если слово уже есть

(*i).add_pos(position); //добавть к нему новую позицию

}

}

}

//Начало программы
int main(){
string str="Testing my Testing my program\0"; //Строка для разбора

vector<dict_el> dict; //Словарь

parse_str(str,dict); //Создать словарь

vector<dict_el>::iterator i;

for(i = dict.begin(); i!= dict.end(); ++i){ //Вывести словарь

cout << *i << endl;

}

return 0;

}

Использование "умных" указателей

Принципы использования "умных" указателей известны каждому программисту на C++. Идея предельно проста: вместо того, что бы пользоваться объектами некоторого класса, указателями на эти объекты или ссылками, определяется новый тип для которого переопределен селектор ->, что позволяет использовать объекты такого типа в качестве ссылок на реальные объекты. На всякий случай, приведу следующий пример:

class A {
public: void method();
}

class APtr {
protected: A* a;
public: APtr();
~APtr();
A* operator->();
};

inline APtr::APtr(): a(new A) { }
inline APtr::~APtr() { delete a; }
inline A* APtr::operator->() { return a; }

Теперь для объекта, определенного как APtr aptr; можно использовать следующую форму доступа к члену a:

aptr->method();

Тонкости того, почему operator->() возвращает именно указатель A* (у которого есть свой селектор), а не, например, ссылку A& и все равно все компилируется таким образом, что выполнение доходит до метода A::method(), я пропущу за ненадобностью --- я не собираюсь рассказывать о том, как работает этот механизм и какие приемы применяются при его использовании --- это очень подробно написано в книге Джеффа Элджера "C++ for real programmers" (комментарий к этой замечательной книге обязательно появится в соответствующем разделе моей странички), в которой вообще буквально половина книги посвящена "умным" указателям.

Преимущества такого подхода, в принципе, очевидны: появляется возможность контроля за доступом к объектам; немного простых телодвижений и получается указатель, который сам считает количество используемых ссылок и при обнулении автоматически уничтожает свой объект, что позволяет не заботиться об этом самостоятельно... не важно? Почему же: самые трудно отлавливаемые ошибки это ошибки в использовании динамически выделенных объектов. Сплошь и рядом можно встретить: попытка использования указателя на удаленный объект, двойное удаление объекта по одному и тому же адресу, неудаление объекта. При этом последняя ошибка, в принципе, самая безобидная: программа, в которой не удаляются объекты (следовательно, теряется память, которая могла бы быть использована повторно) может вполне спокойно работать в течение некоторого времени (причем это время может спокойно колебаться от нескольких часов до нескольких дней), чего вполне хватает для решения некоторых задач. При этом заметить такую ошибку достаточно просто: достаточно наблюдать динамику использования памяти программой; кроме того, существуют специальные средства для отслеживания подобных казусов, например BoundsChecker.

Первая ошибка в этом списке тоже, в принципе, достаточно простая: использование после удаления скорее всего приведет к тому, что операционная система скажет соответствующее системное сообщение. Хуже становится тогда, когда подобного сообщения не появляется (т.е., данные достаточно правдоподобны или область памяти уже занята чем-либо другим), тогда программа может повести себя каким угодно образом.

Вторая ошибка может дать самое большое количество неприятностей. Все дело в том, что, хотя на первый взгляд она ничем особенным не отличается от первой, тем не менее на практике повторное удаление объекта приводит к тому, что менеджер кучи удаляет что-то совсем невообразимое. Вообще, что значит "удаляет"? Это значит, что помечает память как пустую (готовую к использованию). Обычно, менеджер кучи, для того что бы знать, сколько памяти удалить, в блок выделяемой памяти вставляет его размер. Так вот, если память уже была занята чем-то другим, то по "неверному" указателю находится неправильное значение размера блока, таким образом менеджер кучи удалит некоторый случайный размер используемой памяти. Это даст следующее: при следующих выделениях памяти (рано или поздно) менеджер кучи отдаст эту "неиспользуемую" память под другой запрос и... на одном клочке пространства будут ютиться два разных объекта. Крах программы произойдет почти обязательно, это лучшее что может случится. Значительно хуже, если программа останется работать и будет выдавать правдоподобные результаты. Одна из самых оригинальных ошибок, с которой я столкнулся и которая, скорее всего, была вызвана именно повторным удалением одного и того же указателя, было то, что программа, работающая несколько часов, рано или поздно "падала" в... функции malloc(). Причем проработать она должна была именно несколько часов, иначе эта ситуация не повторялась.

Таким образом, автоматическое удаление при гарантированном неиспользовании указателя, это явный плюс. В принципе, можно позавидовать программистам на Java, у которых подобных проблем не возникает; зато, у них возникают другие проблемы;)

Я еще не убедил вас в полезности использования "умных" указателей? Странно. Тогда я приведу примеры реального использования в своих проектах. Вот, например, объявление того самого "умного" указателя с подсчетом ссылок, о котором я говорил:

template<class T>