Лекция 17. Перегрузка операторов
Как вы уже знаете, тип переменной определяет набор значений, которые она может хранить, а также набор операций, которые можно выполнять над этой переменной. Например, над значением переменной типа int ваша программа может выполнять сложение, вычитание, умножение и деление. С другой стороны, использование оператора плюс для сложения двух строк лишено всякого смысла. Когда вы определяете в своей программе класс, то по существу вы определяете новый тип. А если так, C++ позволяет вам определить операции, соответствующие этому новому типу.
Перегрузка оператора состоит в изменении смысла оператора (например, оператора плюс (+), который обычно в C++ используется для сложения) при использовании его с определенным классом. В данном уроке вы определите класс string и перегрузите операторы плюс и минус. Для объектов типа string оператор плюс будет добавлять указанные символы к текущему содержимому строки. Подобным образом оператор минус будет удалять каждое вхождение указанного символа из строки. К концу данного урока вы изучите следующие основные концепции:
Вы перегружаете операторы для улучшения удобочитаемости ваших программ, но перегружать операторы следует только в том случае, если это упрощает понимание вашей программы.
Для перегрузки операторов программы используют ключевое слово C++ operator.
Переопределяя оператор, вы указываете функцию, которую C++ вызывает каждый раз, когда класс использует перегруженный оператор. Эта функция, в свою очередь, выполняет соответствующую операцию.
Если ваша программа перегружает оператор для определенного класса, то смысл этого оператора изменяется только для указанного класса, оставшаяся часть программы будет продолжать использовать этот оператор для выполнения его стандартных операций.
C++ позволяет перегружать большинство операторов, за исключением четырех, перечисленных в таблице 24, которые программы не могут перегружать.
Перегрузка операторов может упростить наиболее общие операции класса и улучшить читаемость программы. Найдите время для эксперимента с программами, представленными в этом уроке, и вы обнаружите, что перегрузка операторов выполняется очень просто.
ПЕРЕГРУЗКА ОПЕРАТОРОВ ПЛЮС И МИНУС
Когда вы перегружаете оператор для какого-либо класса, то смысл данного оператора не изменяется для переменных других типов. Например, если вы перегружаете оператор плюс для класса string, то смысл этого оператора не изменяется, если необходимо сложить два числа. Когда компилятор С++ встречает в программе оператор, то на основании типа переменной он определяет ту операцию, которая должна быть выполнена.
Ниже приведено определение класса, создающее класс string. Этот класс содержит один элемент данных, который представляет собой собственно символьную строку. Кроме того, этот класс содержит несколько различных методов и пока не определяет каких-либо операторов:
class string
{ public: string(char *); // Конструктор void str_append(char *); void chr_minus(char); void show_string(void); private: char data[256] ; };
Как видите, класс определяет функцию str_append, которая добавляет указанные символы к содержимому строки класса. Аналогичным образом функция chr_minus - удаляет каждое вхождение указанного символа из строки класса. Следующая программа STRCLASS.CPP использует класс string для создания двух объектов символьных строк и манипулирования ими.
#include <iostream.h>
#include <string.h>
class string
{ public: string(char *); // Конструктор void str_append(char *); void chr_minus(char); void show_string(void); private: char data[256] ; };
string::string(char *str)
{ strcpy(data, str); }
void string::str_append(char *str)
{ strcat(data, str); }
void string::chr_minus(char letter)
{ char temp[256] ; int i, j; for (i = 0, j = 0; data[i]; i++) // Эту букву необходимо удалить? if (data[i] != letter) // Если нет, присвоить ее temp temp[j++] = data[i]; temp[j] = NULL; // Конец temp // Копировать содержимое temp обратно в data strcpy(data, temp); }
void string::show_string(void)
{ cout << data << endl; }
void main(void)
{ string title( "Учимся программировать на языке C++"); string lesson("Перегрузка операторов"); title.show_string() ; title.str_append(" я учусь!"); itle.show_string(); lesson.show_string(); lesson.chr_minus('p') ; lesson.show_string(); }
Как видите, программа использует функцию str_append для добавления символов к строковой переменной title. Программа также использует функцию chr_minus для удаления каждой буквы " р" из символьной строки lesson. В данном случае программа использует вызовы функции для выполнения этих операций. Однако, используя перегрузку операторов, программа может выполнять идентичные операции с помощью операторов плюс (+) и минус (-).
При перегрузке оператора используйте ключевое слово C++ operator вместе с прототипом и определением функции, чтобы сообщить компилятору C++, что класс будет использовать этот метод как оператор. Например, следующее определение класса использует ключевое слово operator, чтобы назначить операторы плюс и минус функциям str_append и chr_minus внутри класса string:
class string
{ public: string(char *); // Конструктор void operator +(char *); void operator -(char); ————— Определение операторов класса void show_string(void); private: char data[256]; };
Как видите, класс перегружает операторы плюс и минус. Как уже упоминалось, когда класс перегружает оператор, он должен указать функцию, которая реализует операцию, соответствующую этому оператору. В случае оператора плюс определение такой функции становится следующим:
void string::operator +(char *str)
{ strcat(data, str); }
Как видите, определение этой функции не содержит имени, поскольку здесь определяется перегруженный оператор класса. Для перегрузки оператора плюс программа не изменила обработку, которая осуществляется внутри функции (код этой функции идентичен коду предыдущей функции str_append). Вместо этого программа просто заменила имя функции ключевым словом operators соответствующим оператором. Следующая программа OPOVERLD.CPP иллюстрирует использование перегружаемых операторов плюс и минус:
#include <iostream.h>
#include <string.h>
class string
{ public: string(char *); // Конструктор void operator +(char *); void operator -(char); void show_string(void); private; char data[256] ; };
string::string(char *str)
{ strcpy(data, str); }
void string::operator +(char *str)
{ strcat(data, str); }
void string::operator -(char letter)
{ char temp[256] ; int i, j; for (i = 0, j = 0; data[i]; i++) if (data[il 1= letter) temp[j++] = data[i]; temp[j] = NULL; strcpy(data, temp); }
void string::show_string(void)
{ cout << data << endl; }
void main(void)
{ string title( "Учимся программировать на C++"); string lesson("Перегрузка операторов"); title.show_string(); title + " я учусь!"; title.show_string() ; lesson.show_string(); lesson - 'P'; lesson.show_string(); }
Как видите, программа использует перегруженные операторы:
title + " я учусь!"; // Добавить текст " я учусь!"
lesson - 'р'; // Удалить букву 'р'
В данном случае синтаксис оператора законен, но немного непривычен. Обычно вы используете оператор плюс в выражении, которое возвращает результат, например, как в операторе some_str = title + "текст ";. Когда вы определяете оператор, C++ предоставляет вам полную свободу в отношении поведения оператора. Однако, как вы помните, ваша цель при перегрузке операторов состоит в том, чтобы упростить понимание ваших программ. Поэтому следующая программа STR_OVER.CPP немного изменяет предыдущую программу, чтобы позволить ей выполнять операции над переменными типа string, используя синтаксис, который более согласуется со стандартными операторами присваивания:
#include <iostream.h>
#include <string.h>
class string
{ public: string(char *); // Конструктор char * operator +(char *) ; char * operator -(char); void show_string(void); private: char data[256] ; } ;
string::string(char *str)
{ strcpy(data, str); }
char * string::operator +(char *str)
{ return(strcat(data, str)); }
char * string::operator -(char letter)
{ char temp[256]; int i, j; for (i = 0, j = 0; data[i]; i++) if (data[i] 1= letter) temp[j++] = data[i]; temp[j] = NULL; return(strcpy(data, temp)); }
void string::show_string(void)
{ cout << data << endl; }
void main(void)
{ string title("Учимся программировать на C++"); string lesson("Перегрузка операторов"); title.show_string(); title = title + " я учусь"; title.show_string() ; lesson.show_string(); lesson = lesson - '?'; lesson.show_string(); }
Изменив перегруженные операторы плюс и минус таким образом, чтобы они возвращали указатель на символьную строку, программа может теперь использовать эти операторы в привычном для оператора присваивания виде:
title = title + " учимся программировать!";
lesson = lesson - 'р';
Второй пример
При создании ваших собственных типов данных с помощью классов наиболее общей операцией будет проверка, являются ли два объекта одинаковыми. Используя перегрузку, ваши программы могут перегрузить операторы равенства (==), неравенства (!=) или другие операторы сравнения. Следующая программа COMP_STR.CPP добавляет новый оператор в класс string, который проверяет, равны ли два объекта string. Используя перегрузку операторов, ваши программы могут проверять, содержат ли строковые объекты одинаковые строки, как показано ниже:
if (some_string == another_string)
Ниже приведена реализация программы COMP_STR.CPP:
#include <iostream.h>
#include <string.h>
class string
{ public: string(char *); // конструктор char * operator +(char *); char * operator -(char); int operator ==(string); void show_string(void); private: char data[256]; };
string::string(char *str)
{ strcpy(data, str); }
char * string::operator +(char *str)
{ return(strcat(data, str)); }
char * string::operator -(char letter)
{ char temp[256]; int i, j; for (i = 0, j = 0; data[i]; i++) if (data[i] 1= letter) temp[j++] = data[i]; temp[j] = NULL; return(strcpy(data, temp)); }
int string::operator ==(string str)
{ int i; for (i = 0; data[i] == str.data[i]; i++) if ((data[i] == NULL) && (str.data[i] == NULL)) return(1); // Равно return (0); //He равно }
void string::show_string(void)
{ cout << data << endl; }
void main(void)
{ string title( "Учимся программировать на C++"); string lesson("Перегрузка операторов"); string str( "Учимся программировать на C++"); if (title == lesson) cout << "title и lesson равны" << endl; if (str == lesson) cout << "str и lesson равны" << endl; if (title == str) cout << "title и str равны" << endl; }
Как видите, перегружая операторы подобным образом, вы упрощаете понимание ваших программ.
ОПЕРАТОРЫ, КОТОРЫЕ ВЫ HE МОЖЕТЕ ПЕРЕГРУЗИТЬ
В общем случае ваши программы могут перегрузить почти все операторы С++. В табл. 24 перечислены операторы, которые C++ не позволяет перегружать.
Таблица 24. Операторы C++, которые ваши программы не могут перегрузить.
Оператор |
Назначение |
Пример |
. |
Выбор элемента |
object.member |
.* |
Указатель на элемент |
object.*member |
:: |
Разрешение области видимости |
classname::member |
?: |
Условный оператор сравнения |
с = (а > b) ? а : b; |
ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ
Перегрузка операторов — это возможность назначать новый смысл операторам при использовании их с определенным классом. Используя перегрузку операторов, вы можете повысить удобочитаемость ваших программ и облегчить их понимание, выражая операции класса более понятным образом. Чтобы перегрузить оператор, вы должны определить класс, которому оператор будет назначен.
Когда вы перегружаете оператор, перегрузка действует только для класса, в котором он определяется. Если программа использует оператор с неклассовыми переменными (например, переменными типа int или float), используется стандартное определение оператора.
Чтобы перегрузить оператор класса, используйте ключевое слово C++ operator для определения метода класса, который C++ вызывает каждый раз, когда переменная класса использует оператор.
C++ не позволяет вашим программам перегружать оператор выбора элемента (.), оператор указателя на элемент (.*), оператор разрешения области видимости (::) и условный оператор сравнения (?:).
Что такое перегрузка?
Перегрузка - это возможность поддерживать несколько функций с одним названием, но разными сигнатурами вызова. Рассмотрим пример:
double sqrt ( double x ); //Функция корня для чисел с плавающей точкой
int sqrt ( int x ); //Функция корня для целых чисел
...
sqrt(1.5);//В этом случае вызовется функция чисел с плавающей точкой
sqrt(7);//А в этом уже для целых чисел
Компилятор сам определяет какую функцию выбрать в зависимости от сигнатуры. Более подробно о том, как компилятор определяет какую из перегруженных функций выбрать, можно прочесть в стандарте языка С++.
Что такое операторы?
Пример операторов:
+, <<, & и т.д.
Оператор в С++ - это некоторое действие или функция обозначенная специальным символом. Для того что бы распространять эти действия на новые типы данных, при этом сохраняя естественный синтаксис, в С++ была введена возможность перегрузки операторов.
Список операторов:
+ - * / % //Арифметические операторы
+= -= *= /= %=
+a -a //Операторы знака
++a a++ --a a-- //Префиксный и постфиксный инкременты
&& || ! //Логические операторы
& | ~ ^
&= |= ^=
< >> <<= >>= //Битовый сдвиг
= //Оператор присваивания
== != //Операторы сравнения
< > >= <=
Специальные операторы:
&a *a a-> a->*
() []
(type)
. , (a ? b : c)
Не все операторы можно переопределять. Операторы "." и "a?b:c"(тернарный оператор) переопределить нельзя.
Так же нужно отметить, что переопределяя операторы "," "&&" "||" теряются их "ленивые" свойства.
Операторы "a->", "[]", "()", "=" и "(type)" можно переопределить только как методы класса.
Как переопределить оператор?
Рассмотрим как переопределять операторы на примере нашего класса длинной арифметики BigInt.
Бинарный оператор
BigInt operator+(BigInt const & a, BigInt const & b)
{
...
}
Бинарный оператор - это функция от двух параметров, параметрами которой являются левый и правый операнды оператора.
Унарный оператор
BigInt & operator++(BigInt const & b)
{
...
}
Унарный оператор - это оператор от одного параметра. Если он объявлен внутри класса, то этим параметром (неявным) является this.
При перегрузке операторов ">>" и "<<", для ввода и вывода через потоки нужно подключить заголовочный файл iostream.
#include <iostream>
...
std::istream & operator >>(std::istream & is, BigInt & n)
{
...
}
std::ostream & operator <<(std::ostream & os, BigInt const & n)
{
...
}
Переопределение префиксных и постфиксных операторов:
BigInt & operator --(BigInt & n);//Префиксный
BigInt operator --(BigInt & n, int);//Постфиксный
Фактически параметра size_t size у операции нет — он фиктивен. Это хак для того чтобы внести различия в сигнатуры
Переопределение операторов внутри класса:
class BigInt
{
...
BigInt * operator ->();
char operator [](size_t i) const;
char & operator [](size_t i);
...
};
Обратите внимание, что при переопределении "->" необходимо вернуть именно указатель на объект.
Как вы могли заметить, оператор "[]" переопределен как константный и не константный. Во втором случае мы возвращаем ссылку на объект, а не сам объект. Это может быть полезно при определении массивов.
Как правильно перегружать оператор "=" ?
Для перегрузки оператора "=" есть специальная идиома, которая облегчает присваивание сложных объектов. Рассмотрим следующий код:
class BigInt
{
size_t size_;
char * digits_;
BigInt(BigInt const & num)
{
...
}
void swap(BigInt & b)
{
std::swap(size_, b.size_);
std::swap(digits_, b.digits_);
}
BigInt & operator = (BigInt const & num)
{
if(this != &n)
{
BigInt(num).swap(*this);
}
return *this;
}
...
};
Функция std::swap(a,b) - меняет значение a и b местами.
Создав временный объект равный num, поменяем его значения с текущими значениями объекта *this. Выйдя из функции временный объект удалится, а в *this останутся новые значения.
Приведение типов
Часто при разработке новых классов появляется желание приводить уже существующие типы к новому, и наоборот.
B b; A a(b);
Оператор приведения - это противоположность конструктору с одним параметром.
class BigInt
{
operator string() const;
{
string s;
...
return s;
}
};
Важно понять, что в случае
int b;
A a = b;
и во всех подобных случаях, когда необходимо одно значение привести к другому и оператор приведения не определен, то будет вызываться конструктор копирования A::A(int b) от соответствующего типа. Если определить и оператор приведения, и конструктор копирования как не explicit, то при вызове произойдет ошибка компиляции.
Как переопределить пост- и пре- фиксные операторы?
Хорошим тоном является определение постфиксного оператора через префиксный:
BigInt & operator ++()
{
...
return *this;
}
BigInt & operator ++( size_t )
{
BigInt t(*this);
++(*this);
return t;
}
(В этом примере операторы определялись внутри класса BigInt.)
Операторы сравнения
При определении операторов сравнения нет смысла определять их все. Проще определить операторы > или < и ==. А через них уже определить все остальные.
bool operator ==(BigInt const & a, BigInt const & b)
{
...
return ...;
}
bool operator !=(BigInt const & a, BigInt const & b)
{
return !( a == b);
}
bool operator <(BigInt const & a, BigInt const & b)
{
...
return ...;
}
bool operator >(BigInt const & a, BigInt const & b)
{
return b < a;
}
bool operator <=(BigInt const & a, BigInt const & b)
{
return !(a > b);
}
bool operator >=(BigInt const & a, BigInt const & b)
{
return !(a < b);
}
Операторы сравнения лучше определять вне класса. Рассмотрим следующий код:
BigInt a(3);
BigInt b(2);
a < b //выполнится в обоих случаях
a < 2 //Так же выполнится в обоих случаях. "2" приведется к BigInt
3 < b //!!! Будет работать только если оператор сравнения определен вне класса.
//Т.к. нету приведения BigInt к "3"
