На этом шаге мы рассмотрим несколько особенностей, присущих перегрузке стандартных операций.
Механизм классов дает возможность программисту определять новые типы данных, отображающие понятия решаемой задачи. Перегрузка стандартных операций языка C++ позволяет сделать операции над объектами новых классов удобными и общепонятными. Но возникают два вопроса.
Можно ли вводить собственные обозначения для операций, не совпадающие со стандартными операциями языка C++?
И все ли операции языка C++ могут быть перегружены?
К сожалению, вводить операции с совершенно новыми обозначениями язык C++ не позволяет. Ответ на второй вопрос также отрицателен - существует несколько операций, не допускающих перегрузки. Вот их список:
| Прямой выбор компонента структурированного объекта. | |
| Обращение к компоненту через указатель на него. | |
| Условная операция. | |
| Операция указания области видимости. | |
| Операция вычисления размера в байтах. | |
| Препроцессорная операция. | |
| Препроцессорная операция. |
Рассмотрим еще несколько важных особенностей механизма перегрузки (расширения действия) стандартных операций языка C++.
- При расширении действия (при перегрузке) стандартных операций нельзя и нет возможности изменять их приоритеты.
- Нельзя изменить для перегруженных операций синтаксис выражений, т.е. невозможно ввести унарную операцию "=" или бинарную операцию "++".
- Нельзя вводить новые лексические обозначения операций, даже формируя их из допустимых символов. Например, возведение в степень "**" из языка Fortran нельзя ввести в языке C++.
- Любая бинарная операция "@" определяется для объектов некоторого класса двумя
существенно разными способами:
- либо как компонентная функция с одним параметром,
- либо как глобальная (возможно дружественная) функция с двумя параметрами.
В первом случае X @ Y означает вызов X.operator @ (Y), во втором случае X @ Y означает вызов operator @ (X,Y).
В соответствии с семантикой бинарных операций "=", "[ ]", "->" операции-функции с названиями operator =, operator [ ], operator -> не могут быть глобальными функциями, а должны быть нестатическими компонентными функциями.
- Любая унарная операция '$' определяется для объектов некоторого класса также
двумя способами:
- либо как компонентная функция без параметров,
- либо как глобальная (возможно дружественная) функция с одним параметром.
Для префиксной операции "$" выражение $z означает вызов компонентной функции z.operator $ () или вызов глобальной функции operator $ (z).
Для постфиксной операции выражение z$ означает либо вызов компонентной функции z.operator $ (), либо вызов глобальной функции operator $ (z).
- Синтаксис языка C++ определяет некоторые встроенные операции над стандартными типами как комбинации других встроенных операций над теми же операндами. Например, для переменной long m = 0; выражение ++m означает m += 1, что в свою очередь означает выполнение выражения m = m + 1. Такие автоматические замены выражений не реализуются и не справедливы для перегруженных операций. Например, в общем случае определение operator *=() нельзя вывести из определений operator * () и operator = ().
- Нельзя изменить смысл выражения, если в него не входит объект класса, введенного пользователем. Невозможно для операнда m типа int изменить смысл выражения 2 + m и т.п.
- Операция-функция, первым параметром которой предполагается основной (стандартный)
тип, не может быть компонентной функцией. Для объяснения этого ограничения
предположим, что аа - объект некоторого класса и для него расширено действие операции
"+".
При разборе выражения аа + 2 компилятором выполняется вызов операции-функции аа.operator + (2) или operator + (aa,2).
При разборе 2 + аа допустим вызов operator + (2,аа), но ошибочен 2.operator + (аа). Таким образом, расширение действия операции "+" на выражение
допустимо только с помощью глобальных операций-функций.стандартный_тип + объект_класса - При расширении действия операций приходится предусматривать всевозможные сочетания
типов операндов. Например, определяя операцию сложения "+" для комплексных чисел,
приходится учитывать сложение комплексного числа с вещественным и вещественного с комплексным,
комплексного с целым и целого с комплексным и т.д. Если учесть, что вещественные
числа представлены несколькими типами (float, double, long double) и целые числа
имеют разные типы (int, long, unsigned, char), то оказывается необходимым ввести
большое количество операций-функций. К счастью, при вызове операций-функций действуют все
соглашения о преобразованиях стандартных типов параметров, и нет необходимости учитывать
сочетания всех типов. В ряде случаев для бинарной операции достаточно определить только
три варианта:
- стандартный тип, класс;
- класс, стандартный_тип;
- класс, класс.
Например, для рассмотренного класса complex можно ввести как дружественные такие операции-функции:
complex operator + (complex x, complex у) { return complex(x.real + у.real, x.imag + y.imag); } complex operator + (double x, complex y) { return complex(x + y.real, y.imag); } complex operator + (complex x, double y) { return complex(x.real + y, x.imag); }
После этого станут допустимыми выражения в следующих операторах:
complex CC(1.0,2.0); complex ЕЕ; ЕЕ = 4.0 + CC; ЕЕ = ЕЕ + 2.0; ЕЕ = CC + ЕЕ; ЕЕ = CC + 20; // По умолчанию приведение int к double. CC = ЕЕ + 'е'; // По умолчанию приведение char к double.
Вместо использования нескольких (в нашем примере вместо трех) очень схожих операций-функций можно задачу преобразования стандартного типа в объект класса поручить конструктору. Для этого требуется только одно - необходим конструктор, формирующий объект класса по значению стандартного типа. Например, добавление в класс complex такого конструктора:
complex(double x)
{ real = x; imag = 0.0; }
позволяет удалить все дополнительные операции-функции, оставив только одну с прототипом:
friend complex operator + (complex, complex);
В этом случае целый операнд выражения 6 + ЕЕ автоматически преобразуется к типу double, а затем конструктор формирует комплексное число с нулевой мнимой частью. Далее выполняется операция-функция:
operator + (complex(double(6),double(0)), ЕЕ)
Вместо включения в класс дополнительного конструктора с одним аргументом можно в заголовке единственного конструктора ввести умалчиваемое значение второго параметра:
complex(double re, double im = 0.0) { real = re; imag = im; }
Теперь каждое выражение с операцией "+", в которое входит, кроме объекта класса complex, операнд одного из стандартных типов, будет обрабатываться совершенно верно. Однако такое умалчивание является частным решением и не для всех классов пригодно.
Можно было бы в качестве умалчиваемого значения мнимой части взять и число, отличное от нуля, но поведение объектов класса complex при сложении с данными стандартных типов оказалось бы неверным.
На следующем шаге мы продолжим подводить итоги перегрузки операций.
