Перегрузка операторов позволяет в выражениях применять к объектам класса обычные операции, такие как сложение или вычитание.
Перегруженными могут быть практически все операторы, кроме операторов разрешения области видимости, выбора элемента класса, структуры или объединения, условного.
Перегрузка операторов напоминает перегрузку функций и поэтому называется операторной функцией. Однако при этом вводятся некоторые дополнительные правила:
Ø Так как перегружаемый оператор всегда связан с классом, то нельзя переопределять операторы для встроенных типов и нельзя определять дополнительные операторы для встроенных типов;
Ø Нельзя изменять предопределенный приоритет операторов;
Ø Нельзя изменять «-арность» операций, то есть нельзя бинарную операцию сделать унарной или наоборот унарную – бинарной;
Ø Операторная функция может быть перегружена, как и обыкновенная функция с соблюдением правил перегрузки.
Ø Нельзя создавать новых операторов кроме тех, которые определены стандартом С++.
Ø Для операторной функции нельзя задавать стандартные значения параметров.
В общем случае операторная функция объявляется следующим образом:
type operator знак_оператора(список_аргументов);
Часто возвращаемым значением операторной функции является класс, для которого она задана. Однако операторная функция может возвращать любой тип.
Когда операторная функция – член класса перегружает бинарный оператор, для функции достаточно только одного параметра. Этот параметр получит объект, расположенный справа от знака оператора. Объект слева вызывает операторную функцию и передается неявно, посредством использования указателя this.
При создании класса некоторые функции компилятор «подсовывает» по умолчанию. И если Вас не удовлетворяют такие функции, не поленитесь перегрузить их. К таким функциям относится функция присваивания.
Перегрузка унарных операторов напоминает перегрузку бинарных, за исключением того, что мы имеем дело только с одним операндом. Если при этом операторная функция является функцией-членом класса, то у нее не будет параметров. Поскольку имеется только один операнд, он и вызывает операторную функцию.
Иногда нужно объявить два класса, которые так тесно связаны друг с другом концептуально, что хотелось бы обеспечить одному из них неограниченный доступ к членам второго. Проблемы подобного рода в язык С++ решаются через дружественный класс, который имеет доступ как к общим элементам, так и к частным и защищенным элементам класса. Для того, чтобы объявить весь класс или только какую-либо функцию дружественной какому-либо классу используется ключевое слово friend. На еще необъявленный класс можно ссылаться, как на дружественный.
Для перегрузки операторов можно использовать не только функции-члены, но и дружественные функции. При этом необходимо помнить, что в дружественную функцию не передается указатель this. Поэтому в случае бинарного оператора это означает, что дружественной операторной функции явно передаются два параметра, а для унарных операторов требуется один операнд. Все остальное в обоих случаях одинаково. И естественно, при определении дружественной операторной функции вне тела класса не требуется определять область видимости к создаваемому классу.
Перегрузка оператора посредством дружественной функции дает одну очень важную возможность, которой нет у функции – члена класса. Используя дружественную операторную функцию, в операциях с объектами можно использовать встроенные типы данных, которые могут располагаться слева от оператора, что запрещено для функций-членов класса.
Такие свойства дружественной функции делает ее незаменимой для перегрузки операторов ввода/вывода, поскольку в таких операторах левым операндом является объект одного из поточных классов.
Пример 1: Класс, описывающий окружность.
#include <iostream>
#include <conio.h>
#include <windows.h>
#define _USE_MATH_DEFINES
#include <cmath>
using namespace std;
class Circle
{
// Элементы данных:
float x, y, r;
/* дружественные функции ввода и вывода (эти функции должны быть именно дружественными, поскольку левым операндом операции является ссылка на поток, а не окружность): */
// функции – члены класса, обеспечивающие ввод-вывод:
void input();
void output();
// перегрузка операций:
// операция присваивания = :
Circle& operator = (const Circle &);
//операция + :
Circle operator + (const Circle &);
// операция += :
Circle& operator += (const Circle &);
//прочие функции:
float Area() {return M_PI*r*r;}
float Line() {return 2*M_PI*r;}
float Mass_Center(int, const Circle*);
};
// Определение функций:
// перегрузка оператора присваивания:
Circle& Circle::operator = (const Circle &obj)
{
if (this != &obj) // проверка на самоприсваивание (типа с1 = с1;)
{ /* в данном случае просто элементы данных того объекта, который будет стоять слева от знака присваивания (this), становятся равными элементам данных объекта, который будет стоять справа от знака присваивания (obj) */
x=obj.x; y=obj.y; r=obj.r;
}
return *this; /* функция возвращает текущий объект, это позволит выполнять множественное присваивание типа c1 = c2 = c3 */
}
/* перегрузка операции сложения окружностей */
Circle Circle::operator + (const Circle &obj)
{
Circle tmp;
tmp.x = x + obj.x;
tmp.y = y + obj.y;
tmp.r = r + obj.r;
return tmp; /* функция возвращает временный объект, который будет существовать в памяти только во время выполнения операции*/
}
/* перегрузка операции сложения c присваиванием (эта функция позволит изменять параметры окружности, увеличивая или уменьшая их, одной операцией): */
Circle& Circle::operator += (const Circle &obj)
{
x += obj.x;
y += obj.y;
r += obj.r;
return *this; //функция возвращает текущий объект
}
/* функция, которая вычисляет усредненное расстояние от заданной точки (центра текущей окружности) до множестваточек (центров других окружностей), так называемый “центр масс” окружностей, по формуле:
*/
float Circle::Mass_Center(int n, const Circle* obj)
//параметрами функции являются количество точек и массив точек
char* tmp = new char[len+1]; // выделяем память для суммы строк
strcpy(tmp, str); // копируем символы текущего объекта
strcat(tmp, source.str); // добавляем символы второй строки
if (str) delete [] str; // освобождаем память, ранее выделенную текущему объекту
str = tmp; // новая строка становится основой объекта
return *this; // функция возвращает текущий объект
}
// операция + :
String String:: operator + (const String& str2)
{
String str1(str); // создаем временный объект, чтобы не изменять текущий
str1 += str2; // используем уже запрограммированную операцию +=
return str1; // возвращаем временный объект
}
/*операция [], которая позволяет считывать и изменять символы строки, используя номер символа: */
char& String::operator [](int i)
/*тип функции обязательно должен быть ссылкой, иначе невозможно будет изменять символы */
{
assert(i>=0 && i<len); /*функция assert() проверяет условие и, если оно не выполняется, выводит сообщение об ошибке и останавливает работу программы */
return str[i];
}
/*операция (), которая будет выбирать из строки подстроку, начиная с символа с заданным номером index; длина подстроки определяется параметром count */
String String:: operator () (int index, int count)
{
String sub;
if (index <= len-1) // проверяем, не выходит ли индекс за границы строки
{
int ost = len-index;
// определяем, сколько символов осталось до конца строки
sub.len = count>ost ? ost: count;
/* если запрошенное количество символов больше, чем имеется, то функция вернет имеющийся остаток строки */
// функция strncpy() не дописывает признак конца строки
}
return sub;
}
// файл string.cpp:
#include <iostream>
#include <conio.h>
#include <windows.h>
#include "_string_.h"
using namespace std;
int main()
{
//Настройки шрифтов и региональных стандартов:
if(SetConsoleCP(1251)==0)
//проверка правильности установки кодировки символов для ввода
{
cerr<<"Fialed to set codepage!"<<endl;
/* если не удалось установить кодовую страницу, вывод сообщения об ошибке */
}
if(SetConsoleOutputCP(1251)==0)//тоже самое для вывода
{
cerr<<"Failed to set OUTPUT page!"<<endl;
}
do
{
String s1, s2; // исходная и результирующая строки
cout<<"Введите строку: ";
cin>>s1;
int len=s1.GetLength();
if (len)
{
unsigned n;
cout << "На сколько символов сдвинуть строку? ";
cin>>n;
n %= len; /* в результате циклического сдвига на длину строки, она принимает исходное состояние, поэтому имеет смысл выполнять сдвиг только на число, равное остатку от деления n на длину строки */
cout << "Результат:\n";
s2 = s1(n, len-n) + s1(0,n);
// в результате сдвига влево первые n символов уходят в конец строки
cout <<s2<<endl;
/* проверим соответствие выделяемой под строку памяти и количества символов строки (они должны быть равны): */
