Штерн В. - Основы C++. Методы программной инженерии - 2003

левый операнд выражения как первый фактический аргумент функции, а иуааыи как второй аргумент. Генерируемый компилятором код будет в точности совпадать со следующим клиентским кодом:

Если имя функции включает в себя ключевое слово operator и символ опера­ ции, то компилятор воспринимает или вызов функции, или синтаксис операции

игенерирует один тот же код. Когда используется синтаксис z = operator + (х, у);, он сопоставляет типы фактических аргументов с типами параметров (как для любого вызова функции). Если же применяется синтаксис z = х + у;, то компиля­ тор понимает, что используются операнды определяемого программистом типа,

иищет функцию, у которой имя содержит ключевое слово operator и указанный

вклиенте знак операции. Если эта функция найдена, то он проверяет соответствие ее параметров числу и типам операндов в клиентском выражении.

Врезультате обязанности переносятся на серверные классы, а клиентский код избавляется от деталей реализации серверов. Программист, работающий с кли­

ентом, использует один и тот же синтаксис для сложения целых чисел, чисел с плавающей точкой, объектов типа Complex или каких-либо других объектов определяемого типа. И все — с помощью одного синтаксиса.

Это очень гибкий и мощный механизм. Как и многое другое в C+ + , програм­ мист получает больше, чем может ожидать. Мы начали с такой цели, как исполь­ зование объектов определяемых программистом типов как переменных встроенных типов, а закончим более мощными средствами. Теперь можно делать с объектами собственных типов то, о чем и мечтать не приходилось при работе со встроенными числовыми типами. Ведь язык не ограничивает программиста в реализации пере­ груженных операторных функций. Ограничивается только интерфейс функции — ее имя и число параметров. Их нельзя выбирать произвольно. Они должны эмули­ ровать перегруженные встроенные операции.

Перегрузка операторной функции проиллюстрирована в листинге 10.2. Кроме перегруженной операции сложения он показывает применение функции operator+=(), которая складывает один объект Complex с другим. Хотя имена этих двух оператор­ ных функций одинаковы, их список параметров различен. Это законное использо­ вание перегрузки имен (о совмещении имен функции см. в главе 7).

Листинг 10.2. Пример перегрузки операторных функций

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

чтение программы). Такое разделение не считается синтаксической ошибкой.

(арифметика по модулю), для чего делается попытка переопределить операцию сложения целых чисел, установив данное ограничение:

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

Такие же трудности возникают в коде клиента.

int a,b,c; float d,e, f;

a = 20, b = 30; d = 40.0; e = 50.0;

Здесь никак нельзя сообщить компилятору, что нужно использовать — встроен­ ную операцию сложения или перегруженную операцию.

Именно поэтому С+-}- не допускает перегрузки операций для встроенных типов. Можно перегружать операции только для типов, определяемых программистом. Фактически, в CH--f это ограничение обобидается: требуется, чтобы как минимум один параметр в перегруженной операторной функции был параметром определя­ емого программистом типа (классом). В показанной выше попытке ввести допол­ нительную операцию для сложения целых чисел это ограничение нарушается.

О с т о р о ж н о ! Набор операций C++ нельзя расширить за счет символов ^р перегруженных операций, не используемых в качестве встроенных

операций C++. Можно перегружать только существующие операции C++. Нельзя также менять смысл операций со встроенными типами. Разрешается перегружать только операции для типов, определяемых программистом (классов).

Обратите внимание, что во всех случаях создаются перегруженные оператор­ ные функции, а не переопределяются существующие операции. Добавление опе­ рации для объектов Complex не исключает операции сложения для целых чисел

и чисел с плавающей точкой. Перегруженная операция просто добавляется

ксписку операций, известных компилятору C++. Давайте снова рассмотрим эту перегруженную операцию:

Операция сложения в теле такой перегруженной операторной функции пред­ ставляет собой стандартную встроенную операцию для чисел с плавающей точкой. Откуда это известно компилятору? По типам полей данных класса Complex. Поскольку поля имеют тип double, операция сложения не является здесь рекур­ сивным вызовом определяемой перегруженной операции. Аналогичный анализ применяется и к клиентскому коду:

Встречая первую операцию сложения, компилятор устанавливает, что операн­ ды имеют тип Complex, и вызывает перегруженную операторную функцию. Для второй операции сложения он вызывает встроенную операцию, так как операнды имеют тип double.

Ограничения на возвращаемые типы

Обычно перегруженные операторные функции возвраидают либо void, либо булево значение, либо значение того типа, для которого предназначена операция. Часто возврандаются значения типа класса. Это особенно популярно в случае операций, вычисляющих для применения в других выражениях новое значение того же типа. Например, operator+() в приведенных выше примерах возвраидает значение типа Complex, что позволяет использовать данное значение с операцией присваивания. Если бы возвращалось значение типа void, то такое было бы невозможно. Кроме того, возврат значения открывает путь к построению более сложных выражений, аналогичных выражениям со встроенными типами.

Требуется некоторое время, чтобы уяснить суть этого программного кода. Арифметические выражения С+4- ассоциируются слева направо. Если бы а, b и с были числами, то выражение а + b + с означало бы (а + Ь) + с. Перегруженные операторные функции не меняют ассоциативности операций. Если а, b и с — объекты типа Complex, то смысл выражения будет тем же:

В терминах синтаксиса функций выражение означает следующее:

Осталось представить выражение а + ь как вызов функции:

Смысл данного кода в том, что здесь вызывается функция operator+() с пе­ ременными а и Ь, передаваемыми в фактических аргументах, а возвращаемое функцией значение становится первым аргументом функции при втором вызове operator+().

Две перегруженные операторные функции operator+=() из листинга 10.2 возвращают тип void, следовательно, не могут применяться в цепочке, где для дальнейших операций в выражении используется полученное значение.

Чтобы эту операцию можно было использовать в цепочке выражений, нужно построить программу так:

Таким образом можно лучше моделировать поведение встроенных типов, хотя поведение встроенных типов C-f-+ имеет свои недостатки. Оно способствует не разбиению алгоритма на простые последовательные шаги, а написанию запутан­ ных выражений. Вместо изменения программного кода сервера (перегруженной операторной функции) для организации цепочки операций в программе лучше было бы возврандать тип void и разбить код клиента на мелкие шаги, не обяза­ тельно возвраш,аюш,ие значение типа Complex.

Здесь все дело вкуса. Но нужно видеть и понимать разные способы организа­ ции взаимодействия сервера и клиента.

Ограничения на число параметров

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

Изменять арность операции нельзя, т. е. нужно точно задавать число операн­ дов, которые будут с нею использоваться (два для бинарной операции, один — для унарной). Арность перегруженной операции должна быть такой же, как у ориги­ нальной встроенной операции. Нельзя определить бинарную операцию, работаю­ щую с двумя операндами, и использовать ее для создания унарной операции с одним операндом.

Стоит привести пример типичных трудностей, с которыми приходится сталки­ ваться в борьбе с данными правилами. Предположим, нужно реализовать пере­ груженную операцию "меньше чем" (<) для элементов данных типа Complex и организации вывода данных, выполняемого функцией showComplexO из листин­ га 10.2.

Для этого требуется лишь заменить имя showComplex на operator <.

Нетрудно увидеть, как можно использовать такую функцию в клиенте. Она вызывается так же, как функция showComplex():

Итак, первая попытка не удалась. Операторная функция operator < () должна иметь два параметра, а здесь только один — выводимый объект типа Complex. Если неизвестно, что делать с другим операндом, пришлось бы найти другую, "одноместную" операцию.

ВС+-\- есть несколько операций, которые можно использовать как бинарные

иунарные: плюс, минус, звездочка и знак @. Можно перегружать каждую из них как операцию с одним или двумя операндами. Ведь для встроенных типов воз­ можны оба варианта. Например, в нашем примере операция 4- перегружается как бинарная. Поскольку она доступна и как унарный плюс, можно совместить ее, используя функцию с одним параметром. Такая замена для showComplexO вполне законна:

Можно без проблем использовать эту функцию, применяя в клиенте синтаксис операции:

Ограничение на старшинство операций

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

Независимо от типа объектов х и у и смысла операций + и /, деление в выра­ жении X + у/2 будет выполняться перед сложением. Если нужен другой порядок, следует, как обычно, использовать скобки.

О с т о р о ж н о ! При перегрузке операторных функций нельзя изменить число операндов в операции, старшинство операций или их ассоциативность. Разрешается лишь изменять смысл операции для определяемых программистом типов. Это позволяет клиенту применять для определяемых программистом классов и стандартных встроенных типов один и тот же синтаксис выражений.

Перегруженные операции как компоненты класса

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

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

Операцию можно определить как функцию-член класса с параметрами, число которых на единицу меньше арности операции (1 для бинарной, О для унарной). При использовании операции отсутствующий параметр становится адресатом со­ общения.

Замена глобальной функции компонентом класса

Правила перегрузки операторных функций-членов класса совпадают с прави­ лами перегрузки операторных функций как некомпонентных функций. Имя функ­ ции-члена заменяется именем со словом operator и знаком определяемой операции.

Например, бинарные операции operator+() и operator+=(), реализованные как функции-члены класса Complex, должны иметь только один параметр, а не два, как операции в листинге 10.2, реализованные через глобальные функции. Эле­ менты данных параметра, "исчезнувшего" из интерфейса функции, стали элемен­ тами данных адресата сообщения.

Освоившись с этим, будете комфортно чувствовать себя при переходе от неком­ понентной функции с двумя параметрами к функции-члену с одним параметром. Многие программисты предпочитают реализацию с двумя параметрами, посколь­ ку она симметрична: можно складывать соответствующие поля двух параметров.

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

При преобразовании первой операторной функции в функцию-член возникает одна проблема. Здесь используется локальная переменная типа Complex, которая не инициализируется, поскольку неважно, какие значения имеют ее элементы

данных. Эти значения все равно перезаписываются функцией до возврата резуль­ тата клиенту. Такая же схема использовалась в листинге 10.2, и там она работала. Для класса Complex не предусматривались конструкторы — система просто исполь­ зовала конструктор по умолчанию (не выполняющий операций). В новом вариан­ те, приведенном в данном разделе, класс Complex имеет общий конструктор, и, следовательно, компилятор использует его и сообщает о попытке вызова несуще­ ствующей функции в первой строке операторной функции. Таким образом, никог­ да не нужно забывать о конструкторах.

Преодолеть проблему можно двумя способами. Первый состоит в инициализа­ ции локального объекта какими-то ненужными значениями.

Лучший же способ состоит в том, чтобы исключить локальный объект. Вместо него создается неименованный объект Complex, инициализируемый результатами вычислений, и из операторной функции возвращается значение этого неименован­ ного объекта:

Синтаксис операции для функции-члена в точности такой же, как для не члена. Компилятор различает эти вызовы и может интерпретировать выражения, вклю­ чающие в себя вызовы функций-методов с именами, которые содержат ключевое слово operator, и соответствующий знак встроенной операции:

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

Что происходит при перегрузке для одной и той же операции и глобальной функции, и функции-члена? Такую идею хорошей не назовешь. Если эти функции вызываются с помош,ью синтаксиса вызова функций, то компилятор не поймет, что именно имеется в виду. Если же применяется синтаксис операций, то компи­ лятор все равно запутается. Ведь подойдет и та, и другая функция. Обе имеют одинаковое старшинство, и компилятор отвергнет такое выражение как неодно­ значное.

Использование членов класса для цепочек операций

Аналогично некомпонентной реализации возвраш^аемый функцией-членом тип void препятствует использованию синтаксиса операции в цепочке операций. При возврате объекта класса можно организовать выражение-цепочку:

Вновь встроенная операция + ассоциируется слева. Перегруженная операция + также ассоциируется слева, и смысл цепочки операций будет таким:

d=(a + b) + с;

Синтаксис бинарной операции скрывает из виду то, что мы имеем дело с сооб- ш,ением operator+(), передаваемым экземпляру объекта класса Complex. Смысл а + b для реализации функции-члена — это а. operator+(b). Следовательно, кли­ ентское выражение d = (a + b)+G; в точности эквивалентно следуюш.ему:

d = a.operator+(b) + с; / / сообщение возвращаемому значению a.operator+(b)

Здесь operator+ также представляет сообш^ение, передаваемое объекту и возвраш^аемое первым вызовом функции. Следовательно, выражение-цепочка имеет такой смысл:

Результат выполнения программы из лист,инга 10.3