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

Теперь рассмотрим еш,е один тип — Transaction — и попытаемся передать его функции swapAccountsO переменную этого типа. Компилятор пресекает эту попытку, фиксируя синтаксическую ошибку:

Но ведь это, по существу, одинаковые структуры, и хотелось бы использовать для них одну функцию swapAccountsO, а не писать еще одну — swapTransactions(). Я знаю, что делаю, и хотел бы убедить компилятор принять этот код, а не генери­ ровать ошибку. СН-+ предоставляет такую возможность: явное приведение типа. Нужно лишь преобразовать указатель Transaction к типу указателя Account, после чего компилятор примет данный код:

Выглядит довольно неприглядно, но работает, подтверждая мое право на свободу действий. Другие программисты могут сказать, что я ишу приключений на свою голову. Действительно, в процессе сопровождения программы любой из типов — Account или Transaction — могут измениться, и тогда... Да поможет нам Бог. Возможно, надежнее будет все же написать небольшую функцию swapTransactions().

То же правило действует для передачи структур по ссылке. В листинге 7.5 уже показывалась функция printAccountsO, которая ожидает аргументы Account, пе­ реданные по ссылке. Если переменные Transaction передаются как фактические аргументы, то компилятор справедливо заметит, что данный код содержит синтак­ сическую ошибку:

Если бы я настаивал на своем праве сделать это, то мог бы использовать приве­ дение типа Transaction к Account.

printAccounts((Account&)tran1,(Account&)tran2);

/ / нет синтаксической ошибки

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

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

Если бы функция использовала в качестве формального параметра массив конкретного типа, а вместо него подставлялась бы скалярная переменная, структурная переменная или массив, то возникла бы синтаксическая ошибка. C++ блюдет свою репутацию как язык со строгим контролем типов.

Рассмотрим, к примеру, функцию copyAccountsO, копирующую один массив типа Account в другой массив:

Если бы я попытался использовать данную функцию для копирования массива объектов Transaction или массива целых значений, то компилятор справедливо выразил бы свое возмущение:

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

Поскольку переменные типа Transaction имеют тот же размер, что и объекты типа Account, первый вызов функции может дать что-то разумное, в отличие от второго, где вместо int копируется 20 фрагментов памяти размером'Account, что приводит к порче содержимого памяти.

То же самое относится к передаче массивов встроенных скалярных типов. Функция СоруО в предыдущем разделе требует в качестве аргументов массивов double. Если вместо них ей подсунуть int, компилятор выведет сообщение об ошиб­ ке. Если привести фактические аргументы к типу (double*), компилятор сгенериру­ ет объектный код, копирующий память фрагментами длиной double, а не int.

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

Возврат значения из функции

Во всех предыдущих примерах функция возвращала тип void или встроенный скалярный тип int. Конечно, функции C++ возвращают данные по значению. Следовательно, копия возвращаемого значения в области действия функции при­ сваивается переменной в области действия вызывающей программы.

C++ позволяет возвращать из функции структуру, если функция — структур­ ного типа. В приведенных ниже примерах используется модифицированная версия функции swapAccountsO. Как и в предыдущей версии, она сравнивает номера счетов, заданных двумя аргументами Account, и меняет аргументы местами, если они не упорядочены (т. е. номер счета в первом аргументе больше, чем номер счета во втором). В отличие от предыдущей версии, функция возвращает перемен­ ную Account с большим номером счета (параметр а2).

return a2.num; } // плохой возвращаемый тип: нет преобразования изlong

Здесь применяются правила строгого контроля типов. Если B03Bpdu;dcjvjbiii ти определяется как структура (в данном случае Account), то такой же тип должен использоваться в двух других местах — в возвращаемом выражении (в функции) и в переменной в области действия вызывающей программы. Ни выражение, ни переменная в вызывающей программе не могут быть встроенного типа, иметь другой структурный тип или массив. Преобразование между этими типами невоз­ можно:

Аналогично передаче параметров возвращаемые из функции значения требуют координации кода в трех местах:

1)в возвращаемом типе;

2)в возвращаемом выражении;

3)в переменной в области действия вызывающей программы. Вполне законно применение во всех этих трех местах одного и того же типа:

Это допустимо, но при больших структурах и при частом вызове функции будет работать медленно. Именно поэтому большинство функций возвращают тип void, целое или булево значение, которые указывают на успешное или неуспешное выполнение функции.

C++ не позволяет функции возвращать массив, но предоставляет возмож­ ность возвращать указатель или ссылку. Это можно использовать для преодо­ ления проблемы копируемого возвращаемого значения. В следующем примере функция swapAccountsO сравнивает поля num аргументов Account, меняет их местами, если нарушен порядок, и возвращает указатель на переменную Account, у которой номер счета больше:

Здесь типы также должны быть совместимы. Это касается трех мест:

1)объявленного типа, возвращаемого функцией;

2)типа выражения, возвращаемого функцией;

3)типа переменной в области действия.

Account ас1, ас2, асЗ, *ас4; ...

284 Часть II • Объектно-ориентированное программирование но С-^4^

Рассмотрим, например, следующую реализацию функции swapAccountO, воз­ вращающую указатель на структуру. Номер счета для этой структуры берется из параметра a1:

Когда достигается закрывающая фигурная скобка области действия функции, переменная temp уничтожается. Следовательно, указатель ас4 в клиентском коде ссылается не на адрес структуры, содержащей данные из переменной ас1, а на память, уже не принадлежащую программе. Это называется "повисшим" указа­ телем. Такой указатель ссылается на уже исчезнувший объект.

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

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

Возвращать указатели на локальные переменные небезопасно. Более надежно возвращать указатели на переменные в динамически распределяемой области памяти или на переменные в области действия клиента. Вот пример возврата указателя на переменные в области действия^клиента, когда решается проблема "повисшего" указателя:

При возврате указателей на переменные в области действия клиента следует знать, являются ли эти переменные константами. Рассмотрим пример функции, сравнивающей поля bal двух переменных типа Account и возвращающей указатель на объект с большим остатком на счете.

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

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

Встраиваемые функции

Еще одна полезная техника С-}- + , способствующая модульности программы, это так называемые встраиваемые (или подставляемые) функции С4- + . Как уже говорилось выше, копирование аргументов и переключение контекста при вызове функции может повлиять на размер стека программы и ее производительность. Это очень важные вопросы. Если функция небольшая и часто вызывается из функций с большим числом локальных переменных, то жалко тратить время и место в стеке на сохранение среды вызывающей программы ради выполнения нескольких строк кода.

Рассмотрим, например, функцию, вычисляюидую размер налога с помощью по­ стоянного коэффициента.

double tax(double gross) { return gross * 0.05; }

Когда клиентский к,од вызывает эту функцию, "контекст" функции-клиента (ее параметры и локальные переменные, включая массивы) сохраняются в стеке. Когда функция завершает работу, контекст восстанавливается:

Было бы неплохо избежать этих непроизводительных издержек при вызове такой маленькой функции. В языке С эта проблема решается с помощью макро­ команд — литеральной подстановки и имитации вызова функции:

#define tax(x) х*0.05

Клиентский код state = tax(sales); расширяется в state = sales*0.05; — так удается избежать непроизводительных потерь при вызове функции.

C++ поддерживает такие же возможности макрокоманд, как и язык С, однако расширение макрокоманд выполняется препроцессором, а не транслируется ком­ пилятором. Макрокоманда — не функция. Она не может иметь локальных пере­ менных, не предусматривает проверки типа параметров и невидима для отладчика.

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

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

void DnCntO { cnt-; } int GetCntO

{ return cnt; } } ;

В спецификации класса обычно задаются только прототипы функций, а не их реализация.

Если компонентная функция реализована вне фигурных скобок класса, то она

не является по умолчанию встраиваемой. Ее можно определить как встраиваемую с помощью ключевого слова inline:

void Counter::InitCnt(int Value) { cnt = Value; }

inline void Counter::UpCnt()

{ cnt++; }

inline void Counter::DnCnt() { cnt-; }

inline int Counter::GetCnt()

{return cnt; }

Оклассах подробнее рассказывается в следующих главах.

Параметры с заданными по умолчанию значениями

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

Ниже приведено объявление функции sum(), вычисляющей сумму заданного числа компонентов массива значений double. В этом объявлении используется синтаксис инициализации второго формального параметра. Для него по умолча­ нию задается значение 25:

double sum (const double a [ ] , int n=25); / / прототип

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

Конечно, клиентский код может переопределить значение по умолчанию путем явного задания значения фактического аргумента: