Реферат : Turbo C++ Programer`s guide 


Полнотекстовый поиск по базе:

Главная >> Реферат >> Информатика, программирование


Turbo C++ Programer`s guide




TURBO C++

Version 1.0

Programmer's Guide



Оглавление

Введение................................................... Содержание данного руководства............................

Глава 1 Стандарт языка Turbo C++...................

Синтаксис и терминология..................................

Грамматические правила структуры фраз и лексики языка.....

Пробельные символы........................................

"Склеивание" строк символом \........................... Комментарии...............................................

Комментарии C...........................................

Вложенные комментарии...................................

Комментарии C++.........................................

Разделители комментариев и пробелы...................... Лексемы...................................................

Ключевые слова..........................................

Идентификаторы..........................................

Константы...............................................

Константы и их внутреннее представление................. Описание операций.........................................

Унарные операции ...................................... Бинарные операции....................................... Пунктуаторы ..........................................

Объявления................................................ Объекты .............................................. Именующие выражения (Lvalues) ........................ Типы и классы памяти ................................. Контекст ............................................. Видимость............................................... Продолжительность....................................... Единицы трансляции ..................................... Компоновка .............................................

Синтаксис объявления...................................... Предварительные определения .......................... Возможные объявления ................................. Внешние объявления и определения ..................... Спецификаторы типа ..................................... Таксономия типа ...................................... Фундаментальные типы ................................. Инициализация........................................... Простые объявления...................................... Спецификаторы класса памяти............................. Модификаторы............................................ Сложные объявления и деклараторы........................

Указатели.................................................

Указатели объектов......................................

Указатели функций....................................... Объявления указателей ................................ Указатели и константы ................................ Арифметические операции с указателями ................ Преобразования указателей............................... Объявления ссылок в С++ ..............................

Массивы ................................................ Функции...................................................

Объявления и определения ............................. Объявления и прототипы ............................... Объявления ............................................. Объявления формальных параметров ..................... Вызовы функций и преобразования аргументов .............

Структуры................................................. Структуры без тегов и определения типов (typedef)....... Объявления компонентов структуры ..................... Структуры и функции .................................. Доступ к компоненту структуры ........................ Выравнивание по границе слова ........................ Пространство имен структур ............................. Неполные объявления .................................. Битовые поля .........................................

Объединения............................................... Объявления объединений ................................

Перечислимые данные.......................................

Выражения................................................. Выражения и Turbo C++ ................................ Последовательность вычислений ........................ Ошибки и переполнения ................................

Семантика операций........................................

Постфиксные и префиксные операции....................... Операции инкремента и декремента ..................... Унарные операции ..................................... Операция sizeof ..................................... Операции типа умножения .............................. Операции типа сложения ............................... Операции поразрядного сдвига ......................... Операции отношения ..................................... Операции типа равенства .............................. Операция поразрядного И & ............................. Операция поразрядного исключающего ИЛИ ^............... Операция поразрядного включающего ИЛИ \!............... Операция логического И &&.............................. Операция логического ИЛИ \!\!.......................... Условная операция ?:.................................... Операции присвоения .................................. Операция с запятой......................................

Операторы................................................. Блоки ................................................ Операторы-с-метками .................................. Операторы-выражения .................................. Операторы выбора ..................................... Операторы итерации ..................................... Операторы перехода .....................................

С++....................................................... Ссылки ............................................... Операция доступа к контексту ......................... Операции new и delete ................................ Классы ............................................... Виртуальные базовые классы ............................. "Друзья" классов (friend)............................... Конструкторы и деструкторы ............................. Конструкторы ......................................... Деструкторы .......................................... Перегруженные операции ............................... Операции-функции ...................................... Виртуальные функции..................................... Абстрактные классы ..................................... Контекст С++ .........................................

Директивы препроцессора Turbo C++.........................

Пустая директива # .....................................

Директивы #define и #undef ............................. Включение файлов директивой #include ................. Условная компиляция .................................. Директива управления нумерацией строк #line .......... Директива #error ..................................... Директива #pragma....................................... Предопределенные макросы .............................

Глава 2. Перекрестные ссылки по библиотеке исполняющей системы................................................... Зачем нужен доступ к исходным кодам библиотеки исполняющей

системы.................................................. Файлы заголовка Turbo C++................................. Категории библиотечных подпрограмм........................

Глава 3 Потоки С++..................................

Новые потоки вместо старых................................

Использование потоков 2.0................................. Что такое поток? ...................................... Библиотека iostream .................................... Четыре стандартных потока ............................. Вывод ................................................ Ввод.................................................... Инициализация потоков ................................. Простой ввод/вывод в файл ............................. Состояния ошибки потока ввода/вывода....................

Использование потоков прошлых версий......................

Рекомендации по переходу к потокам версии 2.0............. Глава 4 Модели памяти, операции с плавающей точкой и

оверлеи...................................................

Модели памяти.............................................

Регистры 8086...........................................

Сегментация памяти......................................

Указатели...............................................

Шесть моделей памяти.................................... Программирование с использованием различных моделей памяти

адресные модификаторы...................................

Объявление ближних или дальних функций ................ Объявление указателей near, far или huge................ Использование библиотечных файлов....................... Компоновка смешанных модулей ..........................

Опции типа чисел с плавающей точкой....................... Эмулирование платы 80х87................................ Получение кода только для машин с 80х87 ............... Получение кода без операций с плавающей точкой ........ Опция быстрых вычислений с плавающей точкой ........... Переменная операционной среды 87........................ Регистры и 80х87 ......................................

Математические операции с комплексными числами............

Использование двоично-десятичной (BCD) математики....... Использование оперативной памяти Turbo C++................ Оверлеи (VROOMM)..........................................

Работа программ с оверлеями.............................

Требования..............................................

Использование оверлеев .................................

Разработка программ с перекрытиями...................... Свопинг ............................................... Дополнительная память (EMS)............................. Расширенная память (Ext)................................

Глава 5 Видео функции.......................

Несколько слов о видео режимах............................ Несколько слов о текстовых и графических окнах............

Что такое окно ? ..................................... Что такое графическое окно ? .......................... Координаты..............................................

Программирование в текстовом режиме....................... Функции консольного ввода/вывода ....................... Текстовые окна.......................................... Тип text_mode........................................... Цвета текста .......................................... Высокоскоростной вывод: переменная directvideo .........

Программирование в графическом режиме.....................

Функции библиотеки graphics.............................

Управление цветом на CGA................................ Глава 6....................................................

Смешанное программирование................................ Последовательности передачи параметров ...............

Подготовка к вызову .ASM из Turbo C++..................... Упрощенные сегментные директивы ....................... Стандартные сегментные директивы ..................... Определение данных - констант и переменных ............. Определение глобальных и внешних идентификаторов .....

Подготовка к вызову Turbo C++ из .ASM.....................

Ссылки к функциям....................................... Ссылки к данным ......................................

Определение подпрограмм на языке ассемблера............... Передача параметров..................................... Обработка значений возврата ............................

Соглашения о регистрах....................................

Вызов функций С из модулей .ASM...........................

Псевдопеременные, встраиваемые ассемблерные коды и функции прерывания...............................................

Псевдопеременные ..................................... Встраиваемые ассемблерные коды ....................... Функции прерывания...................................... Практические примеры программ низкого уровня .........

Глава 7 Сообщения об ошибках......................

Сообщения об ошибках времени выполнения................... Сообщения об ошибках компилятора.......................... Фатальные ошибки.......................................... Ошибки.................................................... Предупреждения............................................

Приложение АСтандарты ANSI, зависящие от реализации................................................



Введение

Документ "Начало работы" содержит обзор всего комплекта документации к Turbo C++. Информация о том, как с наибольшей эффективностью использовать Руководства по Turbo C++, содержится во введении и главе 2 этого документа.

Данное руководство содержит материалы для углубленного изучения программирования и предназначено для тех, кто уже хорошо умеет программировать (на C, либо на другом языке программирования). Здесь содержится справочник по языку C, перекрестные ссылки по библиотеке исполняющей системы и информациЯ по программированию с использованием потоков C++, моделей памяти, плавающей точки, оверлеев, видео-функций, интерфейса с языком ассемблера, а также сообщения об ошибках исполняющей системы и компилятора.

Прочесть документ "Начало работы" следует, если:

1. Вы ранее никогда не программировали ни на одном языке.

2. Вы ранее программировали, но не на C, и желаете прочесть введение в язык C.

3. Вам нужна информация о том, как установить на компьютере Turbo C++.

В Руководстве пользователя находится информация об интегрированной среде Turbo (включая редактор), администраторе управляющей системы, компиляторе командной строки, дополняющих Turbo C++ утилитах и макроязыке редактора Turbo.

Справочник по библиотеке содержит в алфавитном порядке листинг функций и глобальных переменных Turbo C++.

Содержание данного руководства

Глава 1:"Стандарт языка Turbo C++" описывает язык Turbo C++. Здесь приводятся все отличия от стандарта ANSI C. Данная глава также включает справочник по языкам C и C++.

Глава 2: "Перекрестные ссылки по библиотеке управляющей системы" содержит информацию об исходных кодах библиотеки исполняющей системы. Здесь также описаны файлы заголовков и приводятся перекрестные ссылки по библиотеке управляющей системы, организованные по субъектам библиотеки. Например, если вы хотите выяснить, какие функции относятся к графике, вы должны обратиться к разделу данной главы "Графика".

Глава 3:"Потоки C++" рассказывает, как использовать библиотеку потоков C++.

Глава 4:"Модели памяти, операции с плавающей точкой и оверлеи" рассматривает модели памяти, программирование со смешанными моделями памяти, вычисления с плавающей точкой и оверлеями.

Глава 5:"Видео-функции" посвящена обработке в Turbo C++ текстов и графических изображений.

Глава 6:"Интерфейс с языком ассемблера" говорит о том, как нужно писать программы на языке ассемблера, чтобы они правильно работали при вызове из программ на Turbo C++.

Глава 7: "Сообщения об ошибках" перечисляет и объясняет все фатальные ошибки, ошибки и предупреждения исполняющей системы и компилятора, а также дает возможные рекомендации по их устранению.

Приложение А: "Стандарты ANSI, зависимые от реализации" описывает те аспекты стандарта ANSI C, которые были определены с некоторой степенью свободы или не были определены вообще в стандарте ANSI. Следовательно, эти аспекты могут варьироваться в зависимости от конкретной реализации. Данное приложение сообщает о том, как Turbo C++ поступает в отношении каждого из этих аспектов.

Глава 1 Стандарт языка Turbo C++

В данной главе дается подробное справочноеруководство программиста по языку Turbo C++. Оно не является руководством по изучению языка, а скорее формальным описанием языков C и C++ в их реализации программным продуктом Turbo C++. В данной главе описываются грамматические правила записи структуры фраз и лексики языка, а также дается подробное изложение имеющихся директив препроцессора. При формулировке синтаксиса используется модифицированная запись Бэкуса-Науэра,при необходимости сопровождаемая кратким описанием и примерами программ.

Turbo C++ реализует стандарт ANSI C, разработанный техническим комитетом X3J11 между июнем 1983 и декабрем 1988 гг., с некоторыми расширениями, оговариваемыми вданномтексте. Вы имеете возможность устанавливать опции компилятора, которые будут предупреждать вас о том, чтотакие расширения встретилисьпри работе компилятора. Вы можете также настроить компилятор таким образом, чтобы он рассматривал ключевые слова расширений Turbo C++ в качестве нормальных идентификаторов (см. Главу 4,"Компилятор командной строки", в Руководстве пользователя).

Существуют также "согласующие" расширения, включаемые посредством директив #pragma, предлагаемых стандартом ANSI C, предназначенные для работы с нестандартными, зависимыми от конкретной реализации средствами языка.

Turbo C++ является также полной реализацией AT&TC++ версии 2.00, объектно-ориентированного надмножества C, разработанного Бьерном Строструпом из AT&T Bell Laboratories. Помимо того,что C++ дополняет C многими новыми средствами и возможностями, он также и отличен от него в большей или меньшей степени. В настоящей главе содержатся замечания по этим отличиям. Все средства языка Turbo C++,имеющие отклонения от C++, более подробно рассматриваются, начиная со страницы 98.

Синтаксис и терминология

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

внешнее-определение:

определение-функции

объявление

восьмеричная цифра: одно из

0 1 2 3 4 5 6 7

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

целочисленный-суффикс:

суффикс-целого-без-знака <суффикс-длинного-целого>

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

Грамматические правила структуры фраз и лексики языка

Грамматические правила лексикиязыка Turbo C++ описаны на стр. 5 - 58 оригинала; грамматические правила структуры фраз Turbo C++ описаны на стр. 58 - 98 оригинала.

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

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

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

Сначала выполняется просмотр текста программы препроцессором, который ищет в нем специальные директивы препроцессора (см. стр. 133 оригинала). Например, директива #include <включаемый_файл> добавляет (или включает) впрограмму перед фазой компиляции содержимое файла <включаемый_файл>. Препроцессор также выполняет расширение любых встреченных в программах или файлах включения макросов.

Пробельные символы

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

int i; float f;

и

int i ;

float f;

лексически идентичны, а их лексический анализ в обоих случаях дает шесть лексем:

int i ; float f ;

ASCII-символы, обычно рассматриваемые как пробельные, могут входить в строки литералов, и в данном случаебудут защищены от нормального процессаразбиения на лексемыи пробелы; другими словами, они станут представлять собой часть строки:

char name[] = "Borland International";

разбивается на семь лексем, включая и лексему строки литералов "Borland International".

"Склеивание" строк символом \

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

"Borland \

International"

будет рассматриваться как "Borland International" (дополнительную информацию см. на стр. 17 оригинала, "Строковые литералы"

Комментарии

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

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

Комментарии C

Традиционный комментарий C представляет собой любую последовательность символов, помещаемую послепары символов/*. Признаком конца комментарияслужитперваяпара символов* /, встретившаяся после исходной пары /*. После выполнения макрорасширения вся эта последовательность целиком, включая четыре разделительных символа комментария,заменяется на один пробел. Отметим, чтонекоторые реализации C удаляют комментарии, не заменяя их на пробелы.

Turbo C++ не поддерживает не-мобильной стратегии вставки лексем с помощью /**/. Вставка лексем в Turbo C++ выполняетсяпри помощи заданной ANSI пары символов ##, следующим образом:

#define VAR(i,j) (i/**/j) /* не будет работать */ #define VAR(i,j) (i##j) /* в Turbo C++ будет работать */

#define VAR(i,j) (i ## j) /* также будет работать */

В Turbo C++

int /* объявление */ i /* как счетчика */;

после лексического анализа даст

int i ;

то есть три лексемы: Int I ;

Вложенные комментарии

ANSI C не разрешаетвложенность комментариев. Попытка комментировать приведенную выше строку в виде

/*int /* объявление */ i /как счетчика */; */

окончится неудачей, поскольку область действия первой пары /* будет ограничена первой парой */. Это даст в результате лексического анализа

i ; */

что приведет к генерированию состояния синтаксической ошибки.

По умолчанию Turbo C++ не позволяет вложенность комментариев, однако это умолчание может быть переопределено опцией компилятора. Разрешить вложенность комментариев можно либо при помощи опции -C (компилятора командной строки), либо через меню интегрированной среды программирования O\!C\!Source Options.

Комментарии C++

Для создания вкоде C комментариеввы можете также использовать символы //. Это средство специфично для Turbo C++.

C++ позволяетсоздание размещаемого в одной строке комментария при помощи двух подряд следующихсимволов наклонной черты(//). Такой комментарий может начинаться в любой позиции строки, и включает в себя все, что расположено до символа новой строки:

class X (* // это комментарий

... *);

Разделители комментариев и пробелы

В редких случаях пробелы перед /* и // или после */, хотя и не являются синтаксически обязательными, нопозволяют избежать проблем, связанных с мобильностью. Например, код C++

int i = j//* деление на k*/k;

+m;

при лексическом анализе дастint i = j +m; а не

int i = j/k;

+m;

как это можно было бы ожидать по традиционным соглашениям C. Более удобочитаемая форма

int i = j/ /* деление на k*/ k;

+m;

позволяет избежать этой проблемы.

Лексемы

Turbo C++ распознает лексемы шести классов: ключевые слова, идентификаторы, константы, строковые литералы, операции и знаки пунктуации (также называемые разделителями). Формальное описание лексемы имеет следующий вид:

лексема:

ключевое слово

идентификатор

константа

строковый литерал

операция

знак пунктуации

Во время лексического анализа исходного кода лексемы выделяются методом, при котором из строки символов обязательно выбирается лексема максимальной длины. Например, слово external будетрассматриваться как отдельный идентификатор, а некак ключевое слово extern, за которым следует идентификатор al.

Ключевые слова

Ключевыми словами называются слова, зарезервированныедля специальных целей, которые не должны использоваться в качестве обычных имен идентификаторов. В следующих двух таблицах приводятся ключевые слова Turbo C++. Вы можете использовать опции компилятора командной строки (или опции в IDE), чтобы выбрать только ключевые словаANSI, ключевые слова UNIX и т.д. Информацию об этих опциях см. в главах 1, "Справочник IDE", и 4, "Компилятор командной строки" в Руководстве пользователя.

Все ключевые слова Turbo C++ Таблица 1.1

asm _ds interrupt short

auto else _loadds signed

break enum long sizeof

case _es near _ss

catch _export new static

cdecl extern operator struct

char far pascal switch

class float private template

const for protected this

continue friend public typedef

_cs goto register union

default huge _regparam unsigned

delete if return virtual

do inline _saverages void

double int _seg volatile

while

Расширения Turbo C++ относительно ANSI C Таблица 1.2

cdecl _export _loadds _saveregs

_cs far near _seg

_ds huge pascal _ss

_es interrupt _regparam

Ключевые слова, специфичные для C++ Таблица 1.3

catch friend operator public

class inline private template

delete new protected this

virtual

Регистровые

псевдопеременные Turbo

C++

Таблица

1.4

_AH _BL

_AL _BP

_AX _BX

_BH _CH

_SP

_CL _DL

_CX _DX

_DH _FLAGS

_DI _SI

Идентификаторы

Формальное определение идентификатора имеет следующий вид:

идентификатор:

не-цифра

идентификатор не-цифра

идентификатор цифра

не-цифра: одно из

a b c d e f g h i j k l m n o p q r s t u v w x y z _

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

цифра: одно из

0 1 2 3 4 5 6 7 8 9

Ограничения состава и длины идентификаторов

Идентификаторы представляют собой произвольные имена любой длины, присваиваемыеклассам, объектам, функциям,переменным, определяемым пользователем типам данных ит.д. Идентификаторы могут содержать буквы от A до Z и от a до z, символ подчеркивания (_) и цифры от 0 до 9. Существует только два ограничения:

1. Первый символ должен являться буквой или символом подчеркивания.

Отметим, что идентификаторы в Turbo C++ значимы до любой длины.

2. По умолчанию Turbo C++ распознает только первые 32 символа в качестве значимых. Число значимых символов может быть уменьшено при помощи меню или опций командной строки, но не может быть увеличено. Используйте опцию -In TCC, либо опцию меню O\!C\!S\!Identifier Length, где 1 <= n <= 32.

Идентификаторы и учет регистра

Идентификаторы в Turbo C++ учитывают регистр, и таким образом, Sum, sum и suM - это различные идентификаторы.

Глобальные идентификаторы, импортируемые из других модулей, подчиняются тем же правилам наименования и длины значимости имени, что и обычные идентификаторы. Однако, Turbo C ++ включает в себя опциюподавления учета регистра, обеспечивающую совместимость при компоновке с модулями на языках, не учитывающих регистр. Можно отменить учет регистра для глобальных идентификаторов, установив в диалоговом поле Linker в соответствующее состояние поле Options \! Linker \! Case-Sensitive Link,либо использовав опцию командной строки /C при запуске TLINK. В таком режиме глобальные имена Sum и sum рассматриваются как идентичные, и при компоновке может быть выдано предупреждение "Duplicate symbol" ("Повторяющиеся символические имена").

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

Уникальность и контекст идентификаторов

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

Константы

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

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

Константы - определение формата Таблица 1.5

константа:

константа-с-плавающей-точкой

целочисленная-константа

перечислимая-константа

символьная-константа

константа-с-плавающей-точкой:

дробная-константа <экспоненциальная-часть> <суф-

фикс-константы-с-плавающей-точкой>

последовательность-цифр экспоненциальная часть <суффикс-константы-с-плавающей-точкой>

дробная константа:

<последовательность-цифр>.<последовательность-цифр>

<последовательность-цифр>.

экспоненциальная-часть:

e <знак> последовательность-цифр

E <знак> последовательность-цифр

знак: одно из

+ -

последовательность-цифр:

цифра

последовательность-цифр цифра

суффикс-константы-с-плавающей-точкой: одно из

f l F L

целочисленная-константа:

десятичная-константа <суффикс-целочисленной-константы>

восьмеричная-константа <суффикс-целочисленной-константы>

шестнадцатиричная-константа <суффикс-целочислен-

ной-константы>

десятичная-константа:

цифра-кроме-нуля

десятичная-константа цифра

восьмеричная-константа:

0

восьмеричная-константа восьмеричная-цифра

шестнадцатиричная-константа:

0 x шестнадцатиричная-цифра

0 X шестнадцатиричная-цифра

шестнадцатиричная-константа шестнадцатиричная-цифра

цифра-кроме-нуля: одно из

1 2 3 4 5 6 7 8 9

восьмеричная-цифра: одно из

0 1 2 3 4 5 6 7

шестнадцатиричная-цифра: одно из

0 1 2 3 4 5 6 7 8 9

a b c d e f

A B C D E F

суффикс-целочисленной-константы:

суффикс-константы-без-знака <суффикс-длинной-константы>

суффикс-длинной-константы <суффикс-константы-без-знака>

суффикс-константы-без-знака: одно из

u U

суффикс-длинной-константы: одно из

l L

перечислимая-константа:

идентификатор

символьная-константа:

последовательность-символов-c

последовательность-символов-c:

символ-c

последовательность-символов-c символ-c

символ-c:

любой символ из исходного набора символов, за исключением символов одинарной кавычки ('), обратной наклонной черты (\) или управляющей-последовательности символа новой строки.

управляющая-последовательность: одно из

\* \' \? \\

\a \b\f \n

\o \oo\ooo \r

\t \v\Xh... \xh...

Целочисленные константы

Целочисленные константы могут быть десятичными (основание системы счисления 10), восьмеричными (основание 8)или шестнадцатиричными (основание 16). При отсутствии переопределяющих суффиксов типданныхцелочисленной константы выводится из ее значения, как показано в таблице 1.6. Отметим, что правила для десятичных и не-десятичных констант различны.

Десятичные константы

Допустимыми являются десятичные константы величиной от 0 до 4,294,967,295. Константы, выходящие за указанные пределы, вызывают ошибку. Десятичныеконстанты не могут иметь ведущие нули. Целочисленнаяконстанта с ведущим нулем рассматриваетсякак восьмеричная. Таким образом,

int i = 10; /* десятичное 10 */

int i = 010; /* десятичное 8 */

int i = 0; /* десятичное 0 = восьмеричному 0! */

Отрицательные константы- это просто константы без знака, к которым применена унарная операция минус.

Восьмеричные константы

Все константыс ведущим нулем рассматриваются как восьмеричные.Если восьмеричная константа содержит недопустимые цифры 8 или 9, выдается сообщение об ошибке. Ошибка будет также выдаваться при превышении восьмеричной константой значения 037777777777.

Шестнадцатиричные константы

Все константы, начинающиеся с 0x (или 0X) рассматриваются как шестнадцатиричные. Шестнадцатиричные константы,превышающие 0xFFFFFFFF, приводят к ошибке.

Суффиксы длинных констант и констант без знака

Если законстантой следует суффикс L (или l), то такая константа будет представлена как длинная (типа long).Аналогичным образом, суффикс U (или u) делает константу константой без знака (unsigned). Если численное значение константы превышает десятичное 65,535, независимо от используемого основаниясистемы счисления, то такая константа будет иметь тип unsigned long. Суффиксы можно указывать для одной и той же константы в произвольном порядке и набирать в любом регистре: ul, lu, UL и т.д.

Тип данных константы при отсутствии каких-либо суффиксов вообще (U, u, L или l) берется из следующей таблицы,первыйже, который удовлетворяет требованиям величины этой константы:

-----------------------------------------------------------

десятичная int, long int, unsigned long int

восьмеричная int, unsigned int, long int, unsigned long int

шестнадцатиричная int, unsigned int, long int, unsigned long int

-----------------------------------------------------------

Если константа имеет суффикс U или u, то ее тип данных будет первым из типов unsigned int, insigned long int, который удовлетворит требованиям ее величины.

Если константа имеет суффикс L или l, то ее тип данных будет первым из типов long int, unsigned long int, который удовлетворит требованиям ее величины.

Если константа имеет оба суффикса u и l (ul, lu, Ul, lU,uL, Lu, LU или UL), то она будет иметь тип данных unsigned long int.

В таблице 1.6 сведены представления целочисленных констант для всех трех систем счисления. Указанные типы данных предполагают отсутствие переопределяющих суффиксов L или U.

Целочисленные константы Turbo C++ без L или U Таблица 1.6

Десятичные константы

0 до 32,767 int

32,768 до 2,147,483,647 long

2,147,483,648 до 4,294,967,295 unsigned long

> 4294967295 Генерируется ошибка

Восьмеричные константы

00 до 077777 int

0100000 до 0177777 unsigned int

02000000 до 017777777777 long

020000000000 до 037777777777 unsigned long

> 037777777777 Генерируется ошибка

Шестнадцатиричные константы

0x0000 до 0x7FFF int

0x8000 до 0xFFFF unsigned int

0x10000 до 0x7FFFFFFF long

0x80000000 до 0xFFFFFFFF unsigned long

> 0xFFFFFFFF Генерируется ошибка

Символьные константы

Символьная константа - этоодин или более символов, заключенных в одинарные кавычки, например 'F', '=', '\n'. В C константы изодногосимвола имеюттип Int и имеют внутреннее представление16 бит, в то времякак старший байт слова заполняется нулем или знаком. В C++ константа из одного символа имеет тип char. Многосимвольные константы как в C, так и в C ++, имеют тип данных Int.

Управляющие последовательности

Для введения управляющих последовательностей,позволяющих получить визуальное представление некоторых не имеющих графическогоаналога символов, используется символ обратной наклонной черты (\). Например, в качестве одного символа новой строки можно записать константу \n.

Обратнаянаклонная черта используетсяс восьмеричными или шестнадцатиричными числами для представления ASCII-символами управляющего кода, соответствующемуэтому значению; например, '\03' вместо Ctrl-C или '\x3F' вместо вопросительного знака. В управляющей последовательности может содержаться строка длиной до трех восьмеричных илилюбое число шестнадцатиричных цифр,при условии, чтоданноезначение лежит в допустимом для типа данных char диапазоне (от 0 до 0xff для Turbo C++). Большие значения ведутк появлению ошибки компиляции "Numeric constant too large" ("числовая константа слишком велика"). Например, восьмеричное число \777 больше максимально допустимого значения \377, и вызовет генерирование ошибки. Первое же не-восьмеричноеили не-шестнадцатиричное значение, встреченное в восьмеричнойили шестнадцатиричной управляющей последовательности, означает конец данной последовательности.

В исходной версии Turbo C допускалось только три цифры шестнадцатиричной управляющей последовательности. Новые правила ANSI C, реализованные в Turbo C версии 2.0 и TurboC++, могут вызвать проблемы со старыми кодами, предполагающими преобразование только первых трех символов. Например, при использовании версии Turbo C 1.x для определения строки со звуковым сигналом (код ASCII 7), после которого следуют числовые символы, программист может написать:

printf("\x0072.1Простая операционная система");

Предполагается, что эта строка будет интерпретирована как \x007 и "2.1Простая операционная система". Однако, Turbo C++ (и TurboC версии 2.0) компилируют ее как шестнадцатиричное число \x0072 и литеральную строку ".1Простая операционная система".

Чтобы избежать этих проблем, перепишитеваш код следующим образом:

printf("\x007" "2.1Простая операционная система");

Неоднозначность может возникнуть также и в случае, когда за восьмеричной управляющей последовательностью следует невосьмеричная цифра. Например, поскольку 8 и 9не являются допустимыми восьмеричными цифрами, константа \258 будет интерпретирована какдвухсимвольнаяконстанта, составленная из символов \25 и 8.

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

Управляющие последовательности Turbo C++ Таблица 1.7

Последовательность Значение СимволыВыполняемая функция

\a

\b

\f

\n

\r

\t

\v

\\

0x07BELЗвуковой сигнал

0x08BSЗабой

0x0CFFПеревод бланка

0x0ALFНовая строка (перевод строки)

0x0DCRВозврат каретки

0x09HTТабуляция (горизонтальная)

0x0BVTВертикальная табуляция

0x5c\Обратная наклонная черта

Для фактического представления символа ASCII "обратная наклонная черта", используемого например в команде DOS PATH, следует записывать ее как \\.

\' 0x27 ' Одинарная кавычка (апостроф)

\" 0x22 " Двойная кавычка

\? 0x3F ? Вопросительный знак

\OлюбыеO = строка до трех восьмиричных цифр

\xH любыеH = строка шестнадцатиричных цифр

\XH любыеH = строка шестнадцатиричных цифр

-----------------------------------------------------------

Специальные двух-символьные константы Turbo C++

Turbo C++ поддерживает также двух-символьные константы (например, 'An', '\n\t' и '\007\007'). Эти константы представлены 16-битовыми значениями типаInt, где первый символ расположен в младшем байте, а второй символ - в старшем байте. Эти константы не могут быть перенесены на другие компиляторы C.

Символьные константы со знаком и без знака

В C одно-символьные константы, такие как 'A', '\t' и '\ 007', такжепредставлены 16-битовыми значениями типа Int. В этом случае происходит расширение младшего байта в старший байт по знаку; такимобразом, еслизначение превышает 127 (основание 10), то старший байт устанавливается равным -1 (=0xFF). Это свойство можно отменить, объявив, что по умолчанию тип char является unsigned (при помощи опции -R TCC, либо выбором в меню Options \! Compiler \! CodeGeneration опцию Unsigned Characters), чтоприведет к обнулению старшего байта независимо от значения младшего байта.

Широкие символьные константы (только C)

Символьная константа, которой предшествует L, называется широкой символьнойконстантой и имеет тип данных wchar_t (интегральный тип, определяемый в stdef.h). Например,

x = L 'AB';

Константы с плавающей точкой

Константа с плавающей точкой состоит из шести частей:

- десятичное целое

- десятичная точка

- десятичное дробное

- e или E и целочисленная экспонента со знаком (опционально)

- суффикс типа: f или F, либо l или L (опционально)

Десятичное целое или десятичное дробное (но не то и другое) можно опустить. Можно опустить либо десятичную точку, либо букву e (или E) с целочисленной экспонентой со знаком (но не то и другое). Эти правила позволяют выполнять запись чисел как в обычной, так и в научной (экспоненциальной) форме.

Отрицательные константыс плавающей точкой берутся как положительные константы с префиксом - унарной операцией минус (-).

Примеры:

Константа Значение

6

23.45e6 23.45 x 10

.0 0

0. 0

0

1. 1.0 x 10 = 1.0

-1.23 -1.23

-5

2e-5 2.0 x 10

10

3E+10 3.0 x 10

34

.09E34 0.09 x 10

Константы с плавающей точкой - типы данных

При отсутствии каких-либо суффиксов константы с плавающей точкой имеют тип данных double. Однако, вы можете присвоить константе с плавающей точкой тип данных float, добавив к ней суффикс f или F. Аналогичным образом, суффиксl илиL присвоит константе тип данных long double. В следующей таблице показаны диапазоны значений, которые могут принимать типы данных float, double и long double.

Размеры и диапазоны

констант с плавающей точкой Turbo C++ Таблица 1.8

Тип Размер (в битах) Диапазон значений

-38 38

float 32 3.4 x 10 до 3.4 x 10

-308 308

double 64 1.7 x 10 до 1.7 x 10

-4932 4932

long double 80 3.4 x 10 до 1.1 x 10

Перечислимые константы

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

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

enum team (* giants, cubs, dodgers *);

giants, cubs и dodgers это перечислимые константы типа team, которые могут быть назначены любым переменным типа team или любой другой переменной целочисленного типа. Значения, принимаемые перечислимыми константами,

giants = 0, cubs = 1, dodgers = 2

при условии отсутствия явных инициализаторов. В следующем примере,

enum team (* giants, cubs=3, dodgers = giants + 1 *);

константы установлены следующим образом:

giants = 0, cubs = 3, dodgers = 1

Значения констант не обязаны быть уникальными:

enum team (* giants, cubs = 1, dodgers = cubs - 1 *);

Допустимы также отрицательные инициализаторы.

Строковые литералы

Строковые литералы, известные также как строковые константы, образуют специальную категорию констант, используемых для работы с фиксированными последовательностями символов. Строковый литерал имееттип данных array ofchar и класспамятиstatic, и записываетсякак последовательность произвольного количества символов, заключенных в двойные кавычки:

"Это строковый литерал!"

Нулевая (пустая) строка записывается как "".

Символы внутри двойных кавычек могут включатьуправляющие последовательности (см. стр. 13 оригинала). Например, данный код,

"\t\t\"Имя \"\\\tАдрес\n\n"

распечатается следующим образом:

"Имя "\ Адрес

Слову "Имя " будет предшествовать два символа табуляции; слову Адрес предшествуетодин символтабуляции. Строка заканчиваетсядвумя символами новой строки. Последовательность \" обеспечивает вывод внутренних кавычек.

Строка литерала хранится в памяти как заданная последовательность символов,плюс конечный пустой символ ('\0'). Нулевая строка хранится в виде одного символа '\0'.

На фазе лексического анализа соседние строковые литералы, разделенные толькопробелами, конкатенируются. В следующем примере,

#include <stdio.h>

main()

(*

char *p;

p = "Это пример того, как Turbo C++"

" автоматически\nвыполняет для вас конкатенацию"

" очень длинных строк,\nчто позволяет получить"

" более красивые программы.";

printf(*p*);

*)

На выходе программы будет:

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

Для расширения строковой константы за границы строки в качестве символа продолжения можно использовать обратную наклонную черту (\):

put("В действительности \

это однострочная строка символов");

Константы и их внутреннее представление

ANSI C говорит о том, что размер и численный диапазон базовых типовданных( и различных их модификаций) зависят от конкретной реализации компилятора и в целом от архитектуры компьютера, на котором он установлен. Базовыми компьютерами дляTurbo C++ являются компьютеры семействаIBM PC (и совместимые с ними), поэтому выбор внутреннего представления различных типов данных в целом определяется архитектурой микропроцессоров 8088 и 80x86. В следующей таблице сведены размеры и соответствующие диапазоны значений для типов данных, определяемых в Turbo C++. Дополнительную информацию об этих типах данных см. на стр. 39 оригинала. Внутреннее представление типов данных см. на рис.1.

Типы данных, размеры и диапазоны значений Таблица 1.9

Тип Размер Диапазон Примеры применения

unsigned char8 0 до 255 Малые числа и полный

набор символов PC

char8 -128 до 127 Самые малые числа и

ASCII-символы

enum 16 -32,768 до 32,767 Упорядоченные наборы

значений

unsigned int 16 0 до 65,535 Большие числа и циклы

short int 16 -32,768 до 32,767 Счетчики, малые числа,

управление циклами

int 16 -32,768 до 32,767 Счетчики, малые числа,

управление циклами

unsigned long 32 0 до 4,294,967,295 Астрономические расстояния

long 32 -2,147,483,648 до 2,147,483,647

Большие числа, население

-38 38

float 32 3.4 x 10 до 3.4 x 10

Научные расчеты (точность

7 разрядов)

-308 308

double 64 1.7 x 10 до 1.7 x 10

Научные расчеты (точность

15 разрядов)

-4932 4932

long double 80 3.4 x 10 до 1.1 x 10

Финансовые расчеты

(точность 19 знаков)

near pointer 16 Не существует Манипулирование адресами

памяти

far pointer 32 Не существует Манипулирование адресами

памяти вне текущего

сегмента

<------- направление возрастания значимости

int \!s\!значение\! (дополнение до 2)

15 0

long int \!s\!значение \! (дополнение до 2)

31 0

----------------------

\! \!смещенный\!мантисса\!

float \!s\!порядок \! \!

31 0

--------------------------------

\! \! смещенный \! мантисса \!

double \!s\! порядок \! \!

63 0

----------------------------------------

\! \! смещенный \! \! мантисса \!

long double \!s\! порядок \! \! \!

79 0

s = знаковый бит (0 = положит, 1 = отрицат)

= позиция неявной двоичной точки

1 = целочисленный бит мантиссы: записывается в long double неявно (всегда 1) в float, double

Смещенный порядок (нормализованные значения): float:127 (7FH)

double:1023 (3FFH)

long double: 16,383 (3FFFH)

Рис.1.1 Внутренние представления типов данных

Выражения с константами

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

выражение-с-константами:

условное-выражение

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

- присваивание

- декремент

- вызов функции

- запятая

Описание операций

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

Расширения C++ предлагают дополнительные операции для доступа к компонентам класса и их объектам, атакже механизм перегрузки операций. Перегрузка позволяет переопределять действие любых стандартных операций применительно к объектам заданного класса. В данном разделе мы ограничимся рассмотрением стандартных операций TurboC++. Перегрузка рассматривается, начиная со стр.124 оригинала.

После определения стандартных операций мы обсудим типы данных и объявления, а также объясним, как они влияют на действие каждой операции. Затем мы перейдем к рассмотрению синтаксиса построения выражений с помощью операций, пунктуаторов и объектов.

Операции в Turbo C++ определяются следующим образом:

операция: одно из

[] () . -> ++ --

& * + - тильда !

sizeof / % << >> <

> <= >= == != ^

\! && \!\! ?: = *=

/= %= += -= <<= >>=

&= ^= \!= , # ##

Операции # и ## используются только препроцессором (см. стр. 133 оригинала).

Следующие операции являются специфичными для C++:

:: .* ->*

За исключением операций [], () и ?:, служащих для записи выражений в скобках, многосимвольные операции рассматриваются в качестве одной лексемы. Лексема одной и той же операции может иметьнесколько интерпретаций, в зависимости от контекста. Например,

A * B Умножение

*ptr Обращение по ссылке

A & B Поразрядное И

&A Операция адресации

int & Модификатор указателя (C++)

label: Метка оператора

a ? x : y Условный оператор

void func(int n); Объявление функции

a = (b+c)*d; Выражение со скобками

a, b, c; Выражение с запятой

func(a, b, c); Вызов функции

a = -b; Поразрядное вычитание (дополнение до

единицы)

-func() (*delete a;*) Деструктор (C++)

Унарные операции

& Операция адресации

* Операция обращения по ссылке

+ Унарный плюс

- Унарный минус

тильда Поразрядное дополнение (дополнение до

единицы)

! Логическое отрицание

++ Префикс: пред- инкремент;

Постфикс: пост- инкремент

-- Префикс: пред- декремент;

Постфикс: пост- декремент

Бинарные операции

Операции типа сложения + Бинарный плюс (сложение)

- Бинарный минус (вычитание)

Операции типа умножения * Умножение

/ Деление

% Остаток от деления

Операции сдвига << Сдвиг влево

>> Сдвиг вправо

Поразрядные операции & Поразрядное И

^ Поразрядное исключающее ИЛИ

\! Поразрядное включающее ИЛИ

Логические операции && Логическое И

\!\! Логическое ИЛИ

Операторы присваивания = Присваивание

*= Присвоить произведение

/= Присвоить частное

%= Присвоить остаток

+= Присвоить сумму

-= Присвоить разность

<<= Присвоить сдвиг влево

>>= Присвоить сдвиг вправо

&= Присвоить поразрядное И

^= Присвоить поразрядное исключающее

ИЛИ

\!= Присвоить поразрядное ИЛИ

Операции отношения < Меньше

> Больше

<= Меньше или равно

>= Больше или равно

Операции равенства == Равно

!= Не равно

Операции выбора . Прямой селектор компонента компонента -> Косвенный селектор компонента

Операции с компонентами :: Доступ/разрешение контекста класса .* Обращение через указатель

к компоненту класса

->* Обращение через указатель

к компоненту класса

Условные операции a ? x : y "Если a то x иначе y"

Операция запятой , Вычислить, например, a, b, c слева - направо

Функции этих операций,также как их синтаксис, приоритет и свойства ассоциативности рассматриваются, начиная со стр. 73 оригинала.

Пунктуаторы

В TurboC++ пунктуаторы, также называемые разделителями, определяются следующим образом:

пунктуатор: одно из

[ ] ( ) (* *) , ; : ... * = #

Квадратные скобки

[] (открывающая и закрывающая квадратные скобки) указывают на индексы одно- и многомерных массивов:

char ch, str[] = "Stan"

int mat[3][4]; /* матрица 3 x 4 */

ch = str[3]; /* 4-й элемент */

...

Круглые скобки

() (открывающая и закрывающая круглыескобки) группируют выражения, выделяют условные выражения и указывают на вызовы функций и параметры функций:

d = c * (a + b); /* переопределение нормального приоритета */

/* выполнения операций */

if (d == z) ++x; /* важно при использовании условных операций */

func(); /* вызов функции без аргументов */

int (*fptr)(); /* объявление указателя функции */

fptr = func; /* отсутствие () означает указатель функции */

void func2(int n); /* объявление функции с аргументами */

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

#define CUBE(x) ((x) * (x) * (x))

Использование круглых скобок для изменения нормальных приоритетов операцийи правил ассоциативности см. на стр.76 оригинала.

Фигурные скобки

(**) (Открывающие и закрывающие фигурныескобки) обозначают начало и конец составного оператора:

if (d == z)

(*

++x

func();

*)

Закрывающая фигурная скобка служит терминатором составного оператора, поэтому (;) (точка с запятой) после *) не требуется, за исключением структур или объявлений классов. Часто точка с запятой недопустима, как например в случае

if (оператор)

(**); /* недопустимое использование точки с запятой */

else

Запятая

Запятая (,) отделяет элементы списка аргументов функции:

void func(int n, float f, char ch);

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

func(i, j); /* вызов функции с двумя аргументами */

func((exp1, exp2), (exp3, exp4, exp5)); /* также вызов функции с двумя аргументами */

Точка с запятой

Точка с запятой (;) служит терминатором оператора. Любое допустимое выражениеС (включая и пустое выражение), за которым следует (;), интерпретируется как оператор, называемый оператором выражения. Выражениевычисляется, а его значение отбрасывается. Если такое выражение не имеетпобочных эффектов, то TurboC++ может его проигнорировать.

a + b; /* a + b вычисляется, но полученное значение теряется */

++a; /* имеется побочный эффект для a, но результат ++a */

/* теряется */

; /* пустое выражение = нулевой оператор */

Точки сзапятой частоиспользуются для создания пустых операторов:

for (i = 0; i < t; i++)

(*

;

*)

Двоеточие

Двоеточие (:) служит для обозначения оператора с меткой:

stsrt: x=0;

...

goto stsrt;

...

switch (a)(*

case 1: puts("Первый");

break;

case 2: puts("Второй");

break;

...

default: puts("Ни тот, ни другой!");

break;

*)

Метки рассматриваются на стр.92 оригинала.

Многоточие

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

void func(int n, char ch,...);

Данное объявление указывает, что func будет определена таким образом, что вызовы ее должны содержать как минимум два аргумента, int и char,но также могут иметь и любое число дополнительных аргументов.

В С++ запятую, предшествующую многоточию, можно опустить.

Звездочка (объявление указателя)

Звездочка (*) в объявлении переменной обозначает создание указателя на тип:

char *char_ptr; /* объявление указателя на тип char */

Можно объявить указатели с несколькими уровнями косвенности, что обозначается соответствующим количеством звездочек:

int **int_ptr; /* указатель на указатель на int */

double ***double_ptr /* указатель на указатель на указатель на тип double */

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

i = *int_ptr;

a = b * 3.14;

Знак равенства (инициализатор)

Знак равенства (=) разделяет объявления переменных от списков инициализации:

char array[5] = (* 1, 2, 3, 4, 5 *);

int x = 5;

В функциях С никакой код не может предшествовать никаким объявлениям переменных. В С++ объявления любого типа могут находиться (с некоторыми ограничениями) в любой точке внутри кода.

В списке аргументов функции С++ знак равенства указывает на значение параметра по умолчанию:

int f(int i = 0) (* ... *) /* параметр i имеет значение по умолчанию ноль */

Знак равенства используется также как операция присвоения в выражениях:

a = b + c;

ptr = farmalloc(sizeof(float)*100);

Знак фунта (директива препроцессора)

Знак фунта (#) означает директиву препроцессора, если она является первым не-пробельным символом встроке. Он задает действие компилятора, не обязательно связанное с генерацией кода. Более подробно директивы препроцессора описаны на стр.133 оригинала.

# и ## (двойной знак фунта) также используются как операции замены и слияния лексем на фазе сканирования кода препроцессором.

Объявления

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

Контекст, видимость, продолжительность и тип компоновки определяют части программы,из которых могут быть сделаны допустимые ссылки на идентификатор сцельюдоступа к соответствующему объекту. Контекст обсуждаетсяна стр.29 оригинала, видимость - на стр.30; продолжительность рассматривается, начиная со стр. 31, а тип компоновки - на стр.32.

Объекты

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

Тип используется для

- для определения требуемого количества памяти при ее исходном распределении,

- для интерпретации битовых коды, находимых в объектах при последующих к ним обращениях,

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

Turbo C++ поддерживает многие стандартные (предопределенные), а также определяемые пользователем типы данных, включая целочисленныетипы разных размеров, со знаком и без него, числа с плавающей точкой различной точности представления, структуры, объединения, массивыи классы. Кроме того, имеется возможность устанавливать указатели на большинствоэтих объектов и манипулировать ими со многими моделями памяти.

Стандартные библиотеки Turbo C++, а также ваши собственные программы и файлы заголовковобеспечиваютоднозначные идентификаторы (или выводимые из них выражения) и типы, таким образом, что Turbo C++ можетнепротиворечиво выполнять доступ, интерпретировать и (возможно) изменять битовые коды в памяти, соответствующей каждому активному объекту вашей программы.

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

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

Именующие выражения (Lvalues)

Именующее выражение представляет собой локатор объекта, выражение, которое обозначает объект. Примером именующего выражения может служить *P, где P это выражение, дающее непустой указатель. Модифицируемое именующее выражение -это идентифицирующее выражение, относящееся к объекту, к которому возможен доступ и допустимо его изменение в памяти. Указатель константы const, например, не является модифицируемым именующим выражением. Указатель на константуможетбыть изменен (а подлежащее обращению по этому указателю значение - не может).

Исторически в слове Lvalues буква L означает "левый"; это означает, что Lvalue допускается в левой части (апринимающей части) оператора присваивания. Здесь в левой части оператора присваивания допустимы только модифицируемые именующие выражения. Например, если a и b - это не являющиеся константами целочисленные идентификаторы с правильно распределеннымидля них областями памяти, тооба они являются модифицируемыми именующими выражениями, и присваиваниятипа a = 1;и b = a + b; вполне допустимы.

Значения переменной (Rvalues)

Выражение a + b не можетявляться именующим выражением, и выражение типа a + b = a недопустимо, поскольку выражение в левой части не относится кобъекту. Такие выражения часто называют значением переменной (значение правой части выражения).

Типы и классы памяти

Для связи идентификаторов с объектами требуется, чтобы каждый идентификаторимел как минимум два атрибута: класс памяти и тип (иногда его называют типомданных). КомпиляторTurboC++ определяет эти атрибуты появным или неявным объявлениям в исходном коде программы.

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

Тип, как говорилосьвыше,определяет размер памяти, распределяемый объекту, и то, каким образом программа будет интерпретировать битовыекоды, находящиесяв памяти, распределенной объекту. Типданныхможнорассматриватькак множество значений (часто зависимо от реализации), которые может принимать идентификатор данного типа, совокупно с множеством операций, выполнениекоторых допустимо для значений этого типа. Специальная операциявремени компиляции,sizeof, позволяет определить размер в байтах любого стандартного или определяемого пользователемтипа данных; дополнительную информацию об этой операции см. на стр. 81 оригинала.

Контекст

Контекстом идентификатора называется часть программы, в которой данный идентификатор может быть использован для доступа к связанному сним объекту. Существует пять категорий контекста: блок (или локальный), функция, прототип функции, файл и класс (только для С++). Контекст зависит от того, как и где объявлены идентификаторы.

Контекст блока

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

Контекст функции

Единственными идентификаторами, имеющими контекст типа функции, являются метки операторов. Именаметок могут быть использованыв операторах goto влюбой точке функции,где объявлена данная метка. Метки объявляютсянеявно; для этого записывается имя_метки: и за ним оператор. Имена меток в пределах функции должны быть уникальными.

Контекст прототипа функции

Идентификаторы, объявленные в списке объявлений

параметров в прототипе функции (не являющиеся частью определения функции) имеют контекст прототипа функции.Конец этого контекста совпадает с концом прототипа функции.

Контекст файла

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

Контекст класса (С++)

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

Контекст и пространства имен

Пространство имен - это контекст, в пределах которого идентификатордолженбыть уникальным. В С существует четыре раздельных класса идентификаторов:

1. Имена меток операторов goto. Эти имена должны быть уникальными в пределах функции, в которой они объявлены.

2. Теги структур, объединений и перечислимых данных. Они должны быть уникальными в пределах блока, в котором они определены. Теги, объявленные вне какой-либо функции, должны быть уникальными относительно всех тегов, определенных вовне.

В С++ структуры, классы и перечислимые данные относятся к одному и тому же пространству имен.

3. Имена компонентовструктур и объединений. Они должны быть уникальными в пределах структуры или блока, в которомони определены. На тип или смещение с одним и тем же именем в различных структурах ограничений не существует.

4. Переменные, определения типа и компоненты перечислимых данных. Они должны бытьуникальными вконтексте, где они определены. Идентификаторы, объявленные внешними, должны быть уникальными среди переменных, объявленных вовне.

Видимость

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

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

Видимость не может выходить за пределы контекста; но контекст может превышать видимость.

...

(*

int i; char ch; // автоматическое распределение по умолчанию

i = 3; // int i и char ch в контексте и видимы

...

(*

double i;

i = 3.0e3; // double i в контексте и видима

// int i в контексте, но скрыта

ch = 'A'; // char ch в контексте и видима

*)

// double i вне контекста

i += 1; // int i видима и равна 4

... // char ch все еще в контексте и видима

// и равна 'A'

*)

... // int i и char ch вне контекста

И снова, специальные правила действуют в отношение скрытых имен классов и имен компонентов классов: специальные операции С++ позволяют доступ к скрытымидентификаторам при определенных условиях (см. стр.103 оригинала).

Продолжительность

Продолжительность, близко связаннаяс классом памяти, определяет продолжительность периода, в течение которого объявленным идентификаторам соответствуют распределенные в памяти реальные физические объекты. Такжеделается различие между объектами времени компиляции и времени выполнения. Например, переменным, в отличие от определяемых типов (typedefs) и типов, память непосредственно во время выполнения не распределяется. Существует три вида продолжительности: статическая, локальная и динамическая.

Статическая продолжительность (static)

Объекты со статическойпродолжительностью жизни получают распределение памяти сразу жепри начале выполнения программы; такоераспределение памяти сохраняется до выхода из программы. Объекты со статической продолжительностью обычно размещаются в фиксированныхсегментах данных, распределенных в соответствии с используемой моделью памяти. Все функции, независимо от того,где они определены, являются объектами состатической продолжительностью. Также статическую продолжительность имеютвсе переменные сфайловым контекстом. Прочим переменным может быть задана статическая продолжительность, еслииспользовать явные спецификаторы класса памяти static или extern.

При отсутствии явного инициализатора, либо вС++ конструктора, объекты со статической продолжительностью инициализируются в ноль (или пустое значение).

Статическую продолжительность не следует путать с файловым или глобальным контекстом. Объектможетиметьстатическую продолжительность и при этом локальный контекст.

Локальная продолжительность (local)

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

Объектыс локальнойпродолжительностью жизни, иначе

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

При объявлении переменных (например, int, char, float) спецификатор класса памяти register такжеподразумевает auto, однако компилятору при этом передается запрос (или рекомендация) о том, что при возможности данный объект желательно разместить в регистре. Turbo C++можно установить таким образом, чтобы он распределял регистрлокальной интегральной переменнойили переменной типа указатель, если какой-либо регистр свободен. Если свободных регистров нет, то переменная распределяется как auto, или динамический локальный объект, без выдачи предупреждения или генерации ошибки.

Динамическая продолжительность (dynamic)

Объекты с динамической продолжительностью жизни создаются и разрушаются конкретными вызовами функций при выполнении программы. Им распределяется памятьиз специального резерва памяти, называемого кучей, при помощи либо стандартных библиотечных функций, какнапример malloc, либо при помощи операции С++ new. Соответствующая отмена распределения выполняется при помощи free или delete.

Единицы трансляции

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

единица-трансляции:

внешнее-объявление

единица-трансляции внешнее-объявление

внешнее-объявление:

определение-функции

объявление

Слово external имеет в С несколько значений; в данном случае оно относится к объявлениям, находящимся вне каких-либо функций, и которые, следовательно, имеют контекст файла. (Отдельным свойством является внешний тип компоновки; см.следующий раздел, "Компоновка".) Любое объявление, также резервирующее память для объекта или функции, называется определением (или объявлением определения). Более подробную информацию см. в разделе "Внешние объявления и определения" на стр.36 оригинала.

Компоновка

Выполняемая программа обычно создается компиляцией нескольких независимых единиц трансляции, а затем компоновкой получившихся объектных файлов с уже существующими библиотеками. Проблема возникает, когда один и тот же идентификатор объявлен в разных контекстах (например, в различных файлах), либо объявлен более одного раза в одном и том же контексте. Компоновка это процесс, который позволяетправильно связатькаждое вхождение идентификатора с одним конкретным объектом или функцией. Все идентификаторы имеют один из трех атрибутовкомпоновки, тесно связанных с их контекстом: внешняя компоновка, внутренняя компоновка или отсутствие компоновки. Эти атрибуты определяются местоположением и форматом объявлений, а также явным (или неявным по умолчанию) использованием спецификатора класса памяти static или extern.

Каждое вхождение конкретного идентификатора с типом компоновки external представляет тот же самый объект или функцию во всем множестве файлов и библиотек, составляющих программу. Каждое вхождение конкретного идентификатора с типом компоновки internal представляет тот же самый объект или функцию только в пределах одного файла. Идентификаторы с типом компоновки no (отсутствие) представляет уникальные элементы программы.

Ниже приводятсяправила внешней (external) и внутренней (internal) компоновки:

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

Для С, если один и тот же идентификатор в пределах одного файла появляется и с внутренним, и с внешним типом компоновки, то идентификатор будет иметь внутренний тип компоновки.

2. Если объявление идентификатора объекта или функции содержит спецификатор класса памяти extern, то идентификатор имеет тот же тип компоновки, что и видимое объявление идентификатора с файловым контекстом. Если такого видимого объявления не имеется, то идентификатор будет иметь внешний тип компоновки.

3. Если функция объявлена без спецификатора класса памяти, то ее тип компоновки определяется, как если бы был использован спецификатор класса памяти extern.

4. Если идентификатор объекта с файловым контекстом объявлен без спецификатора класса памяти, то идентификатор имеет внешний тип компоновки.

Следующие идентификаторы не имеют атрибута типа компоновки:

1. Любой идентификатор, объявленный иначе, чем объект или функция (например, идентификатор typedef).

2. Параметры функции.

3. Идентификаторы с контекстом блока в случае объектов, объявленных без спецификатора класса памяти extern.

Синтаксис объявления

Все шесть взаимосвязанных атрибута (класс памяти, тип, контекст, видимость,продолжительность и тип компоновки) могут быть разными способами определены при помощи объявлений.

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

Предварительные определения

СтандартANSI C вводит новуюконцепцию: предварительное определение. Любое объявление внешних данных, не имеющее спецификаторакласса памяти и инициализатора, рассматривается как предварительное определение. Еслиобъявленный идентификатор появляется в последующемопределении, то предварительное определение рассматривается,как если бы имелся спецификатор класса памяти extern .Другими словами, предварительное определение становится простым объявлением ссылки.

Если достигнут конец единицы трансляции, а для идентификатора так и не было встречено определения с инициализатором, то предварительное определение становится полным определением, а для определенного таким образом объекта резервируется неинициализированная (заполненнаянулями) область памяти. Например,

int x;

int x; /* допустимо, резервируется одна копия x */

int y;

int y = 4; /* допустимо, y инициализируется значением 4 */

int z = 5;

int z = 6; /* недопустимо, т.к. оба определения

инициализированы */

Возможные объявления

В число объектов, которые могут быть объявлены, входят:

- переменные

- функции

- классы и компоненты классов (С++)

- типы

- теги структур, объединений и перечислимых данных

- компоненты структур

- компоненты объединений

- массивы прочих типов

- перечислимые константы

- метки операторов

- макросы препроцессора

Полный синтаксис объявлений показан в следующих таблицах. Рекурсивная природа синтаксиса описателей позволяет создавать сложные описатели. Для улучшения читаемости мы пошли на использование определяемого типа (typedef).

Синтаксис объявлений Turbo C++ Таблица 1.10

объявление:

<спецификаторы-объявления> <список-деклараторов>

объявление-asm

объявление-функции

спецификация-типа-компоновки

спецификатор-объявления:

спецификатор-класса-памяти

спецификатор-типа

спецификатор-функции

friend (только для С++)

typedef

спецификаторы-объявления:

<спецификаторы-объявления> спецификатор-объявления

спецификатор-класса-памяти:

auto

register

static

extern

спецификатор-функции: (только для С++)

inline

virtual

спецификатор-типа:

имя-простого-типа

спецификатор-класса

спецификатор-перечислимых-данных

спецификатор-усовершенствованного-типа

const

volatile

имя-простого-типа:

имя-класса

имя-typedef

char

short

int

long

signed

unsigned

float

double

void

спецификатор-усовершенствованного-типа:

ключ-класса идентификатор

ключ-класса имя-класса

enum имя-перечислимых-данных

ключ-класса: (только для С++)

class

struct

union

список-перечислимых-данных:

нумератор

список-нумераторовнумератор

нумератор:

идентификатор

идентификатор = выражение-типа-константы

выражение-типа-константы:

условное-выражение

спецификация-типа-компоновки: (только для С++)

extern строка (* <список-объявления> *)

extern строка объявление

список-объявления:

объявление

список-объявления объявление

Для следующей таблицы отметим, что на количество и порядок модификаторов и квалификаторов наложены ограничения. Кроме того, перечисленные модификаторыявляются единственнымдополнением синтаксиса декларатора, не входящим в стандарт ANSI C и С++. Каждый модификатор подробно описан, начиная со стр.46 оригинала.

Синтаксис декларатора Turbo C++ Таблица 1.11

список-декларатора:

инициализатор-декларатор

список-декларатораинициализатор-декларатор

инициализатор-декларатор:

имя-декларатора

список-модификаторов

операция-указателядекларатор

декларатор (список-объявления-параметров)

<список-со-квалификаторов>

(список-со-квалификаторов - только для С++)

декларатор [<выражение-типа-константы>]

список-модификаторов:

модификатор

список-модификаторов модификатор

модификатор:

cdecl

pascal

interrupt

near

far

huge

операция-указателя:

* <список-со-квалификаторов>

& <список-со-квалификаторов> (только для С++)

имя-класса = *<список-со-квалификаторов> (только для C++)

список-со-квалификаторов:

со-квалификатор <список-со-квалификаторов>

со-квалификатор:

const

volatile

имя-декларатора:

имя

имя-класса (только для С++)

имя-класса (только для С++)

имя-typedef

имя-типа:

спецификатор-типа <абстрактный-декларатор>

абстрактный-декларатор:

операция-указателя <абстрактный-декларатор>

<абстрактный-декларатор> (список-аргументов-объявления) <список-со-квалификаторов>

<абстрактный-декларатор> [<выражение-типа-константы>]

список-объявления-аргументов:

<список-объявления-арг>

список-объявления-арг, ...

<список-объявления-арг>...(только для С++)

список-объявления-арг:

объявление-аргументов

список-объявления-арг объявление-аргументов

объявление-аргументов:

спецификаторы-объявления декларатор

спецификаторы-объявления декларатор = выражение (только для С++)

спецификаторы-объявления <абстрактный-декларатор>

спецификаторы-объявления <абстрактный-декларатор> =выражение (только для С++)

определение-функции:

<спецификаторы-объявления> декларатор <инициализатор>

тело-функции

тело-функции:

составной оператор

инициализатор:

= выражение

= (список-инициализаторов)

(список-выражений) (только для С++)

список-инициализаторов:

выражение

список-инициализаторов , выражение

(список-инициализаторов<,>)

Внешние объявления и определения

Спецификаторы класса памяти auto и registerво внешнем объявлении появиться не могут (см. "Единицы трансляции"). Для каждого идентификатора в единице трансляции, объявленной с внешним типомкомпоновки, может существовать не более одного внешнего определения.

Внешнее определение - это внешнее объявление, которое также определяет объект или функцию;таким образом, оно также распределяет память. Если идентификатор, объявленный с внешним типомкомпоновки, используется в выражении (не являющемся частью операции sizeof), то во всей программе должно иметьсяв точности одно внешнее определение данного идентификатора.

Turbo C++ позволяет затем переобъявление внешних имен, таких как массивы, структуры и объединения, добавляя информацию к ранее выполненным объявлениям. Например,

int a[] // нет размера

struct mystruct; // только тег, без объявления компонентов

...

int a[3] = [1, 2, 3]; // задание размера и инициализация

struct mystruct (*

int i, j;

*); // добавление деклараторов компонентов

Объявления классов Turbo C++ (только С++) Таблица 1.12

спецификатор-класса:

заголовок-класса (<список-компонентов>)

заголовок-класса:

ключ-класса <идентификатор> <базовый-спецификатор>

ключ-класса имя-класса <базовый-спецификатор>

список-компонентов:

объявление-компонента <список-компонентов>

спецификатор-доступа : <список-компонентов>

объявление-компонента:

<спецификаторы-объявления><список-декларатора-компонентов>;

определение-функции <;>

квалифицированное-имя;

список-декларатора-компонентов:

декларатор-компонента

список-декларатора-компонентов, декларатор-компонента

декларатор-компонента:

декларатор <pure-спецификатор>

<идентификатор> : выражение-типа-константы

pure-спецификатор:

=0

базовый-спецификатор:

:базовый-список

базовый-список:

базовый-спецификатор

базовый-список, базовый-спецификатор

базовый-спецификатор:

имя-класса

virtual <спецификатор-доступа> имя-класса

спецификатор-доступа Юvirtual> имя-класса

спецификатор-доступа:

private

protected

public

имя-функции-преобразования:

operator имя-типа-преобразования

имя-типа-преобразования:

спецификация-типа <операция-указателя>

инициализатор-конструктора:

: список-инициализаторов-памяти

список-инициализаторов-памяти:

инициализатор-памяти

инициализатор-памяти, список-инициализаторов-памяти

инициализатор-памяти:

имя-класса (<список-аргументов>)

идентификатор (<список-аргументов>)

имя-функции-операции:

operator операция

операция: одно из

new delete sizeof

+ - * /% ^

& \! != <>

+= -= *= /=%= ^=

&= \!= << >>>>= <<=

== != <= >=&& \!\!

++ -- , ->*-> ()

[] .*

Спецификаторы типа

Спецификатор типа с одним или более опциональным модификатором используется для задания типа объявляемого идентификатора:

int i; // объявление i как целого со знаком

unsigned char cH2, cH3; // объявление двух символьных без знака

По устоявшейся традиции, если спецификатор типа опущен, то по умолчанию назначается тип signed int (или, что эквивалентно, int). Однако, в С++ встречаются ситуации, когда отсутствие спецификатора типа ведет к синтаксической неоднозначности, поэтому в практике работы с С++ используется явный ввод всех спецификаторов типа int.

Таксономия типа

Существует четыре базовые категории типа: void, scalar, function и aggregate. Типы scalar и aggregate могут далее подразделяться следующим образом:

- Scalar: арифметический, перечислимый, указатель и в С ++ ссылки

- Aggregate: массив, структура, объединение и в С++ класс

Типы делятся на фундаментальные и производные. К фундаментальным относятся: void, char, int, float и double совместно с short, long, signed, а также некоторые варианты с ними unsigned. Производные типы включают в себя указатели и ссылки на другие типы,массивы других типов, типы функций, типы классов, структуры и объединения.

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

Задав не-пустойтип type (с некоторыми предосторожностями), можно объявлять производные типы следующим образом:

Объявление типов Таблица 1.13

type

t; Объект типа type

type

type

array[10]; Десять типов: array[0]-array[9]

*ptr; ptr это указатель типа

type

type

&ref=t; ref = ссылка на тип (C++)

func(void); func возвращает значение типа type

void

func1(type t); func1 принимает параметр типа type

struct st (type t1; type t2); структура st содержит два типа

Ниже показано, как производные типы могут быть объявлены в пределах класса:

class cl (* // класс cl содержит указатель ptr на тип, плюс

// функцию, принимающую параметр type (C++)

type *ptr;

public:

void func(type*);

Тип void

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

- Пустой список параметров в объявлении функции:

int func(void); // функция не принимает аргументов

С++ обрабатывает 0 специальным образом. См. раздел "Объявления и прототипы" на стр.60 и примеры кода на стр.61 оригинала.

- Когда объявленная функция не возвращает значений:

void func(int n); // возвращаемое значение отсутствует

- В качестве родового указателя. Указатель на void является родовым указателем на все что угодно:

void *ptr; // далее ptr может быть установлен на любой

// объект

- Выражения с проверкой типа:

extern int errfunc(); // возвращает код ошибки

...

(void) errfunc(); // значение возврата теряется

Фундаментальные типы

signed и unsigned - это модификаторы, применяемые к интегральным типам.

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

char int signed

double long unsigned

float short

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

Интегральные типы

Типы char, short, int и long, а также их варианты unsigned называются интегральными типами. Ниже приводятся спецификаторы интегральных типов с помещенными в той же строке синонимами.

Интегральные типы Таблица 1.14

char,signed char Если по умолчанию char установлен как signed, то это синонимы

unsigned char

char,unsigned char Если по умолчанию char установлен как

unsigned, то это синонимы

signed char

int,signed int

unsigned,unsigned int

short,short int,signed short int

unsigned short,unsigned short int

long,long int,signed long int

unsigned long,unsigned long int

С типами char,short, int или long можно использовать либо signed, либо unsigned. Если же использовать только сами ключевые слова signed или unsigned, то они означают signed int или unsigned int, соответственно.

В отсутствие слова unsigned обычно принимается тип signed. Исключение возникаетв случае char. Turbo C++ позволяет устанавливатьдля char умолчание signed или unsigned. (Если вы не устанавливали это умолчание сами, то это умолчание будет равно signed). Если умолчание установлено в значение unsigned, то объявление char ch объявит ch как unsigned. Для переопределение этогоумолчания нужно задать signed char ch. Аналогичным образом, если для char установлено умолчание signed, то для объявления ch как unsigned char следует явно указать unsigned char ch.

С int можно использовать либо long, либо short. Если ключевые словаlong или short использованы сами по себе, то они означают long int или short int, соответственно.

ANSI C не устанавливаетразмеры внутреннего представления этих типов, за исключением того, что размеры данных short, int и long образуют неубывающую последовательность"short <= int <= long". Все три типа могут быть одинаковыми. Это существенно для написания мобильных кодов, предназначенных для переноса на другую аппаратную базу.

В Turbo C++ типы int и short эквивалентны, и имеют оба длину 16 бит. long представляет 32-битовые объекты. Их разновидность с ключевым словом signed хранятся вформате дополнения до двух, причем в качестве знакового бита используется MSB (наиболее значащий бит): 0 означает положительное число, 1 - отрицательное (что объясняет диапазоне, приведенные в таблице 1.9). В версиях unsigned дляхранения числа используются все биты, что дает диапазон 0-(2^n-1), где n = 8,16 или

32.

Типы с плавающей точкой

Представления и множества принимаемых значений для типов с плавающей точкой зависят от конкретной реализации; то есть каждая новая реализация компилятора С свободна определять их по-своему. TurboC++ использует форматы с плавающей точкой IEEE. (Приложение А, "Стандарты ANSI, зависимые от реализации" содержит более подробную информацию по этому вопросу.)

float иdoubleпредставляют собой 32- и 64-разрядные типы данных с плавающей точкой, соответственно. long можно использовать с double для получения 80-разрядной точности представления идентификатора с плавающей точкой: long double test_case, например.

Распределяемая для типов с плавающей точкой память показана в таблице 1.9.

Стандартные преобразования

При использовании арифметических выражений, таких как a +b, где a и b - это данные различных арифметических типов, Turbo C++ выполняет передвычислениемопределенные внутренние преобразования. Эти стандартные преобразования включают в себя перевод "низших" типов в "высшие" в интересах точности представления и непротиворечивости данных.

Ниже приводятся шаги, выполняемые Turbo C++для преобразования операндов в арифметических выражениях:

1. Все малые интегральные типы преобразовываются согласно таблице 1.15. После этого любые два значения, участвующие в операции, становятся либо Int (включая модификаторы long и unsigned), либо double, float или long double.

2. Если один из операндов имеет тип long double, то второй операнд также будет преобразован к типу long double.

3. Иначе, если один из операндов имеет тип double, то второй операнд также будет преобразован к типу double.

4. Иначе, если один из операндов имеет тип float, то второй операнд также будет преобразован к типу float.

5. Иначе, если один из операндов имеет тип unsigned long, то второй операнд также будет преобразован к типу unsigned long.

6. Иначе, если один из операндов имеет тип long, то второй операнд также будет преобразован к типу long.

7. Иначе, если один из операндов имеет тип unsigned, то второй операнд также будет преобразован к типу unsigned.

8. В противном случае оба операнда имеют тип Int.

Результат вычисления выражения будет того же типа, что и оба участвующих в нем операнда.

Методы стандартных арифметических преобразований Таблица 1.15

Тип Преобразование вМетод

char intРасширение нулем или знаком

(в зависимости от умолчания

для типа char)

unsigned char intЗаполнение старшего байта

нулем (всегда)

signed char intРасширение знаком (всегда)

short intТо же значение

unsigned short unsigned int То же значение

enum intТо же значение

Специальные преобразования типов char, int и enum

Обсуждаемые в данном разделе преобразования специфичны для Turbo C++.

Присваивание объекта типа signed char (например,переменной) интегральномуобъекту вызывает автоматическое расширение знаком. Объекты типа signed char используетрасширение знаком всегда; объекты типаunsigned charпри преобразовании вint всегда устанавливают старший байт в ноль.

Преобразование более длинных интегральных типов к более коротким типам ведет к усечению старших битов, оставляя младшие без изменения. Преобразование более короткого интегрального типа к более длинному либо расширяет лишние биты нового значения знаком, либо заполняет их нулем, в зависимости от того, является ли более короткий тип signed или unsigned, соответственно.

Инициализация

Инициализаторы устанавливают исходное значение,хранимое в объекте (переменные,массивы, структуры, и т.д.). Если вы не инициализируете объект, и он имеет статическую продолжительность существования, то он будет инициализирован по умолчанию, следующим образом:

- нулем, если это объект арифметического типа

- null, если что указатель

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

Синтаксис инициализаторов следующий: инициализатор

= выражение

= (*список-инициализаторов*)<,>*)

(список выражений)

список-инициализаторов

выражение

список-инициализаторов, выражение

(*список-инициализаторов*)<,>*)

Ниже приводятся правила, управляющие инициализаторами:

1. Число инициализаторов в списке инициализаторов не может превышать число инициализируемых объектов.

2. Инициализируемый элемент должен быть типа объекта или массивом неизвестной размерности.

3. Все выражения должны являться константами, если они находятся в одном из следующих мест:

а. в инициализаторе объекта, имеющего статическую длительность (в Turbo C++ не требуется)

b. в списке инициализаторов для массива, структуры или объединения (также допустимы выражения с использованием sizeof)

4. Если объявление идентификатора имеет контекст блока, и идентификатор имеет внешнюю или внутреннюю компоновку, объявление не может иметь инициализатор для идентификатора.

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

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

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

- списком инициализаторов, как описано в следующем разделе

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

Массивы, структуры и объединения

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

int days[7] = (* 1, 1, 1, 1, 1, 1, 1)

Этими правилами можновоспользоваться для инициализации символьных массивов и широких символьных массивов:

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

char name[] = (* "Unknown" *);

установив тем самым массив из восьми элементов, элементы которого равны 'U'(для name[0]), 'n' (для name[1]), и т.д. (включая нулевой терминатор.)

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

Ниже приводится пример инициализации структуры:

struct mystruct (*

int i;

char str[21];

double d;

*) s = (* 20, "Borland", 3.14 *);

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

Простые объявления

Простые объявления идентификаторов переменных имеют следующий шаблон:

тип-данных перем1 <=иниц1>, перем2 <=иниц2>,...;

где перем1, перем2, ... это произвольная последовательность отдельных идентификаторов с опциональными инициализаторами. Каждая из переменных объявляется с указанным типом-данных. Например,

int x = 1, y = 2;

создает две целочисленных переменных x и y (и инициализирует их значениями 1 и 2, соответственно).

Это былиобъявления определения; при этом распределялась память и выполнялась инициализация.

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

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

Спецификаторы класса памяти

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

auto register typedef

extern static

Использование спецификатора класса памяти auto

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

Использование спецификатора класса памяти extern

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

Использование спецификатора класса памяти register

Спецификатор класса памяти registerдопустим только в объявлениях локальных переменных и параметров функций. Он эквивалентен класса auto, за исключением того, что компилятору в данном случае делается запрос о размещении при возможности данной переменной в регистре. Распределение для переменной регистра может значительно уменьшить размер программы и увеличить скорость ее выполнения во многих случаях. Однако, поскольку TurboC++ итак предпринимает мерыдля возможного размещения переменных в регистре, необходимость в явном задании ключевого слова register возникает редко.

Turbo C++ позволяет вам выбрать опции размещения переменных в регистрах в диалоговом поле Options \! Compiler \! Optimization. При выборе опции Automatic TurboC++ сделает попытку распределить регистры даже еслиспецификаторы класса памяти register не задавались.

Использование спецификатора класса памяти static

Спецификатор класса памяти static может использоваться в объявлениях функций и переменных с контекстом файла и локальным контекстом для обозначения внутреннего типакомпоновки. Static также указывает, что переменная должна иметьстатическую продолжительность существования. При отсутствии конструкторовили явныхинициализаторов статические переменные инициализируются 0 или null.

В С++ компоненты класса,статические данные, имеет то же значение длявсех вхождений класса. Члены класса, статические функции, не зависят от других вхождений класса.

Использование спецификатора класса памяти typedef

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

static long int biggy;

typedef long int BIGGY;

Первое объявление создает 32-битовый объект типа long int, со статической продолжительностью существования и именем biggy. Второе объявление устанавливает идентификатор BIGGY в качестве спецификаторановоготипа, не создавая при этомкакого-либо объекта времени выполнения. BIGGY можно использовать в последующих объявлениях,там, где допустимо задаватьспецификатор типа. Например,

extern BIGGY salary;

имеет тот же эффект, что и

extern long int salary;

Хотя данный простой пример может быть равным образом реализован при помощи #define BIGGY long int, в более сложных случаях typedef позволяет добиться большего, нежели с помощью текстовых подстановок.

Важное замечание!

typedef не создает новых типов данных; это ключевое слово просто создает полезные мнемонические синонимы, или алиасы,для существующих типов. Это особенно полезно для упрощения сложных объявлений:

typedef double (*PFD)();

PFD array-pfd[10];

/* array_pfd это массив из 10 указателей на функции,

возвращающие значения типа double */

Нельзя использовать идентификаторы typedef со спецификаторами других типов:

unsigned BIGGY pay; /* НЕДОПУСТИМО */

Модификаторы

Помимо ключевых слов спецификатора класса памяти, объявление можетиспользовать конкретные модификаторы, предназначенные для изменения некоторых аспектов распределения памяти идентификатора/ объекта. В следующей таблице сведены модификаторы, имеющиеся в Turbo C++.

Модификаторы Turbo C++ Таблица 1.16

Модификатор Используется с Использование

const Только переменными Предотвращает изменения объекта

volatile Только переменными Предотвращает распределение

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

В С++ const и volatile расширены и включают классы и функции.

Расширения Turbo C++

cdecl Функции Устанавливает соглашения С пере-

дачи аргументов

cdecl Переменные Устанавливает учет регистра иден-

тификатора и ведущие знаки подчеркивания

pascal Функции Устанавливает соглашения пере-

дачи аргументов Паскаля

pascal Переменные отменяет учет регистра идентифи-

катора и ведущие знаки подчеркивания

interrupt Функции Функция компилируется с дополни-

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

near, Переменные Переопределяет умолчание типа

far, указатели указателя, задаваемое текущей

huge моделью памяти

_cs, Переменные Указатели сегмента;

_ds, указатели см. стр.199 оригинала

_es,

_seg,

_ss

near, Функции Переопределяет умолчание типа

far, функции, задаваемое текущей

huge моделью памяти

near, Переменные Определяет размещение объекта в

far, памяти

_export Функции Только OS/2. Turbo C++ это

игнорирует

_loadds Функции Устанавливает регистр DS на

текущий сегмент данных

_saveregs Функции Предохраняет все значения регис-

тров (кроме значений возврата)

во время выполнения функции

Модификатор const

Модификатор const предотвращает любые присваивания данному объекту, а также прочие побочные эффекты, такие как инкремент или декремент объекта. Указатель const неможет быть модифицирован, хотя сам объект, на который он указывает, может. Рассмотрим следующие примеры:

const float pi= 3.1415926;

const maxint = 32767;

char *const str= "Hello, world!"; // указатель константа

char const *str2= "Hello, world!"; // указатель на константу

Использование одного только модификатораconst эквивалентно const int.

С учетом этого, следующие операторы являются недопустимыми:

pi= 3.0; /* присвоение значения константе */

i= maxint++; /* инкремент константы */

str = "Hi, there!"; /* установка указателя str на что-то еще

Однако, отметим, что вызов функции strcpy(str,"Hi, there!") является допустимым, поскольку он выполняет посимвольное копирование из строкового литерала "Hi, there!" в адрес памяти, указываемый str.

В С++ const также "скрывает" объект const и предотвращает внешнюю компоновку. При необходимости нужно использовать extern const. Указатель на const не может быть присвоен указателю на неconst (в противном случае значению const могло было быть выполнено присвоение при помощи указателя на не -const.) Например,

char *str3 = str2 /* запрещено */

Модификатор функции прерывания interrupt

Модификатор interrupt специфичен для Turbo C++. Функции прерывания предназначены для работы с векторами прерывания 8086/8088. Turbo C++ компилирует функцию interrupt с дополнительным кодом входа и выхода, таким образом, чтобы сохранялись регистры AX, BX, CX, DX, SI, DI, ES иDS. Прочие регистры (BP, SP, SS, CS и IP) сохраняются как часть вызывающей последовательности С или как часть самого обработчикапрерываний. Для возвратафункция использует команду Iret, поэтому функция можетслужить для обслуживания аппаратных илипрограммных прерываний. Ниже показан пример типичного определения interrupt:

void interrupt myhandler()

(*

...

*)

Вы должны объявлять функции прерывания с типом void. Функции прерывания могут быть объявлены с любой моделью памяти. Для всех моделей памяти, кроме huge, DS устанавливается на сегмент данных программы. В случае модели huge DS устанавливаетсяна сегмент данных модуля.

Модификатор volatile

В C++ volatile имеетспециальное значение для функций компонентов класса. Если вы объявили объект volatile, вы можете использовать для него только функции компонентов volatile.

Модификатор volatile указывает, что данный объект может быть модифицирован не только вами, но также и извне вашей программы, например, подпрограммой прерывания или портом ввода/вывода. Объявление объекта volatile предупреждает компилятор, что тот не должен делать допущений относительно значения объекта во время расчета содержащих его выражений, поскольку его значение (теоретически) можетв любой момент измениться. Компилятор также не будет делать такую переменную регистровой переменной.

volatile int ticks;

interrupt timer()

(*

ticks++;

*)

wait(int interval)

(*

ticks = 0;

while (ticks < interval); // не делает ничего

Эти подпрограммы (предполагается, что timer правильно связана с аппаратным прерыванием часов) реализуют выдержкупо времени между"тиканьем" часов, заданную аргументом interval. Высоко оптимизированный компилятор не может загружать значение ticks в проверку выхода из цикла while, так как цикл не изменяет значения ticks.

Модификаторы cdecl и pascal

Turbo C++ позволяет вашим программам легко вызывать подпрограммы, написанные на других языках, и наоборот.При смешанном программировании приходится иметь дело с двумя важными вопросами: идентификаторы и передача параметров.

В Turbo C++ все глобальные идентификаторы сохраняются в своем исходном виде (строчные, заглавныебуквы и их комбинации) с присоединенным в начале идентификатора знакомподчеркивания (_), если вы не выберете опцию-u- (GenerateUnderbars...Off) в диалоговом поле Options \! Compiler \! Code Generation).

На стр.32 оригинала рассказано, как использовать extern,что позволяет ссылаться на имена С из программы на C+ +.

pascal

В Паскале глобальные идентификаторы не сохраняются в своем исходном виде и не имеют первым символом знак подчеркивания. Turbo C++ позволяют объявлять любые идентификаторы как имеющие тип pascal; тогда такойидентификатор преобразовывается к верхнему регистру, и ему непредшествует знак подчеркивания. (Если идентификатор является функцией,то что также влияет на используемую последовательность передачи параметров;подробности см. на стр. 51 оригинала, "Модификаторы типа функции".)

Опция компилятора -p (Calling Convention...Pascal в диалоговом поле Options \! Compiler \!Code Generation) вызывает обработку функций (и указателей на эти функции) как если бы они имели тип pascal.

Модификатор pascal специфичен для Turbo C++; он предназначен для функций (и указателей функций), использующих последовательность передачи параметров Паскаля. Кроме того, функции, объявленные с типом pascal, могут тем не менее вызываться из подпрограмм С, если последним известно, что данная функция имеет тип pascal.

pascal putnums(int i, int j, int k)

(*

printf("And the answers are: %d, %d, and %j\n",i,j,k); *)

Функции типа pascal немогут принимать переменное число аргументов, в отличие от таких функций, как printf. Поэтому в определении функции типа pascal использовать многоточие (...) нельзя.

cdecl

Программа main должна быть объявлена как cdecl, поскольку загрузочный код С всегда пытается вызвать главную процедуру (main) по соглашениям С.

После компиляции программы с опцией -pвам может понадобиться,чтобы некоторые идентификаторы сохранили регистр, в котором они были первоначально набраны, и ведущий знак подчеркивания, особенно если это идентификаторы С из другого файла. Это можно сделать, объявив этиидентификаторыкак cdecl. (Это также влияет на передачу параметров функциям).

Как и pascal, модификатор cdecl специфичен для Turbo C+ +. Он используется с функциями и указателями функций. Этотмодификатор переопределяет директиву компилятора -p и позволяет вызывать такую функцию как правильную функцию С. Например, если вы компилируете предыдущую программус установленной опцией -p, но желаете использовать printf, то нужно сделать следующее:

extern cdecl printf();

putnums(int i, int j, int k);

cdecl main()

(*

putnums(1,4,9);

*)

putnums(int i, int j, int k)

(*

printf("And the answers are: %d, %d, and %j\n",i,j,k); *)

При компиляции такой программы с опцией -p все функции из библиотеки исполняющей системы должны иметь объявление cdecl. Если вы посмотрите файлы заголовка (такие как stdio.h), вы увидите, что с учетом этого каждая функция определена там как cdecl.

Модификаторы указателей

Turbo C++ имеет восемь модификаторов, влияющих на операцию обращения поссылке, то есть на модификацию указателей в данные. Эти модификаторы: near, far, huge, _cs, _ds, _es, _seg и _ss.

С позволяет выполнять компиляцию с использованием одной из нескольких моделей памяти. Используемая вами модель определяет (помимо всего прочего) внутренний формат указателей. Например, при использованиималой данных small (tiny, small, medium)все указатели данных содержат 16-битовое смещение регистра сегмента данных (DS). При использовании большой модели данных (compact, large, huge)все указатели данных имеют длину 32 бита и содержат как адрес сегмента, так и смещение.

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

Углубленное рассмотрение указателей near, far и huge см. на стр. 192 оригинала в главе 4, а описание нормализованных указателей см. на стр. 193 оригинала. Кроме того, см. на стр. 199 оригинала обсуждение _cs, _ds, _es, _seg и _ss.

Модификаторы типа функции

Модификаторы near, far и huge могут также использоватьсякак модификаторы типа функции; т.е., они могут модифицировать, помимо указателей данных, функции и указатели функций. Кроме того,для модификации функций могут служить модификаторы _export, _loadds и _saveregs.

Модификаторы функций near, far и huge могут комбинироваться с модификаторами cdecl или pascal, но не с interrupt.

Функции типа huge полезны для интерфейса с кодами на языке ассемблера, не использующими такое же,как вTurbo С++, распределение памяти.

Функции,не имеющие модификатора interrupt, могут быть объявлены как near,far или hugeс тем, чтобы переопределить установки текущей модели памяти по умолчанию.

Функция near использует ближние (near) вызовы; функцияfar или huge использует дальние (far) команды вызова.

В случае моделей памяти tiny, small и compact функция, где это не было задано явно, имеет по умолчанию тип near. В моделях medium и large по умолчанию функция имеет тип far. В модели памяти huge по умолчанию используется тип huge.

Функция huge аналогична функции far, за исключением того, что при входе вфункцию huge регистрDS устанавливается на адрес сегмента данных исходного модуля, нодля функции far остается неустановленным.

Модификатор _export лексически анализируется, но игнорируется. Он обеспечивает совместимость с исходными модулями, написанными для OS/2. Для программ в DOS модификатор _export никакого значения не имеет.

Модификатор _loadds указывает, что функция должна устанавливатьрегистр DS аналогично тому, как это делает функция huge, но не подразумевает вызовов near или far. Таким образом, _loadds far эквивалентно объявлению huge.

Модификатор _saveregsзаставляет функцию сохранитьвсе значения регистров и затем восстановить их перед возвратом(за исключением явных значений возврата, передаваемых в таких регистрах AX или DX.)

Модификаторы _loadds и_saveregs полезны при написании подпрограмм интерфейса нижнего уровня, как например, подпрограммы поддержки мыши.

Сложные объявления и деклараторы

Синтаксис декларатора см. на стр.35 оригинала.Определение включает в себя деклараторы идентификаторов и функций.

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

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

Формат декларатора указывает на то, каким образом объявленное имя-декларатора должно интерпретироваться при использовании в выражениях. Если type это любой тип, а спецификатор-класса-памяти это любой спецификатор класса памяти, то объявление

спецификатор-класса-памятиtype D1, D2;

указывает, что каждое вхождение D1 или D2 в выражение будет рассматриваться как объект типа "type" и с заданным "классом-памяти". Тип имени-декларатора, входящего в декларатор, должно быть некоторой фразой, содержащей type, например "type", "pointer to type", "array of type", "function returning type" или "pointer to function returning type", и т.д.

Например, в объявлениях

int n, nao[], naf[3], *pn, *apr[], (*pan)[], &nr=n

int f(void), *frp(void), (*pfn)(void);

каждый из деклараторов мог бы быть использован в качестве значения переменной (правой части) (или, возможно, в некоторых случаях в качестве именующего выражения (левой части) ) в выражениях, где допустим один объект int. Типы встроенных идентификаторов берутся из их деклараторов следующим образом:

Сложные объявления Таблица 1.17

Синтаксис Подразумеваемый тип имени Пример

type имя; type int count;

type имя[] (открытый) массив array of type int count[1];

type имя[3]; Фиксированный массив из трех int count[3];

элементов типа type

(name[0],name[1],name[3])

type *имя; Указатель на type int *count;

type *имя[]; (открытый) массив указателей int *count[];

type *(имя[]) То же самое int *(count[]);

type (*имя)[]; Указатель на (открытый) массив int (*count)[];

типа type

type &имя; Ссылка на тип type (только С++) int &count; type имя(); Функция, возвращающая тип type int count(); type *имя(); Функция, возвращающая указатель int *count();

на тип type

type *(имя()); То же самое int *(count());

type (*имя)(); Указатель на функцию, возвращающую int (*count)();

тип type

Отметим необходимость круглых скобок в (*имя)[] и (*имя)(), поскольку приоритет декларатора массива [] и декларатора функции () выше, чем декларатора указателя *. Круглые скобки в *(имя[]) опциональны.

Указатели

Обсуждение создания ссылок и обращения по ссылкам (разыменования) см. на стр.80 оригинала.

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

Два этиклассауказателей имеют отличные друг от друга свойства, назначения и правила манипулирования, хотя и те и другие разделяют между собойопределенные операцииTurbo C++. Вообще говоря, указатели функций используются для доступа к функциям и для передачиодних функцийдругим в качествеаргументов; выполнение арифметических операцийс указателямифункций не допускается. И напротив, указателиобъектов при сканировании массивов или более сложных структур памяти регулярно инкрементируются и декрементируются.

Хотя указатели содержат числа сбольшинством характеристик типаunsigned int, они имеют свои собственные правила и ограничения на присвоения, преобразования ивыполнение с ними арифметических действий. Примеры в следующих нескольких разделах иллюстрируют эти правила и ограничения.

Указатели объектов

"Указатель на объект типа type" содержит адрес (то есть указывает) объекта с типом type. Поскольку указатель сам по себе является объектом, то вы можете установить указатель на указатель (и т.д.). В число прочих объектов,на которые обычно устанавливается указатель, входят массивы, структуры,объединения и классы.

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

Указатели функций

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

Указатель функции имеет тип "указатель функции, возвращающей тип type", где type есть тип возвращаемых функцией данных.

В С++, где контроль типов данных болеестрогий, указатель функции имеет тип "указатель функции принимающей агрументы типа type и возвращающей тип type". Действительно, в С функция, определенная с типами аргументов, также будет иметь данный, более узкий тип. Например,

void (*func)();

В С это будет указатель функции, не возвращающей никаких значений. В С++ это указатель функции, не принимающей никаких аргументов и не возвращающей никаких значений. В примере

void(*func)(int);

*func это указатель функции, принимающей аргумент int и не возвращающей никаких значений.

Объявления указателей

Подробное описание типа void см. на стр.39 оригинала.

Объявление указателя всегда должно устанавливать его на некоторый конкретный тип, даже если этот тип void (что фактическиозначает указатель на любой тип). Однако, уже после объявления указатель обычно может быть переназначен на объект другого типа. Turbo C++ позволяет переназначать указатели без приведения в соответствие типа, но компилятор выдаст при этом предупреждение, если только первоначально указатель не был объявлен с типом void. В С (но не в С++) вы можете назначить указатель void* на указатель, не имеющий тип void*.

Если type есть любой предопределенный или определенный пользователем тип, включая void, то объявление

type *ptr;/* Опасно - неинициализированный указатель */

объявит ptr как "указатель на тип type". К объявленному таким образомобъекту ptr применимы все правила, связанные с контекстом, продолжительностью и видимостью.

Указатель со значением null это адрес, гарантированно отличный от любого допустимого указателя, используемого в программе. Присвоение указателю целой константы 0 присваивает указателю значение null.

Указатель типа "указатель на void" не следует путать с нулевым (null) указателем. Объявление

void *vptr;

объявляет, что vptr - это родовой указатель, которомуможет быть присвоено любое значение "указатель на тип type" без выдачи компилятором сообщений. Присвоения без правильного приведения типов между "указателем на тип type1" и "указателем на тип type2", где type1 и type2 это различные типы, может вызвать предупреждение или ошибку компилятора. Если type1 это функция, а type2 нет (или наоборот), присваивания указателей недопустимы. Если type1 это указатель на void, приведения типов не требуется. Если type2 это указатель на тип void, то в С приведение не нужно.

Ограничения присвоения также существуют относительно указателей разных размеров (near, far и huge). Можно присвоить меньший указатель большему, не вызвав ошибки, но нельзя выполнить обратную операцию, не выполнив явную операцию приведения. Например,

char near *ncp;

char far *fcp;

char huge *hcp;

fcp = ncp; // допустимо

hcp = fcp; // допустимо

fcp = hcp; // недопустимо

scp = fcp; // недопустимо

scp = (char nesr*)fcp; // теперь допустимо

Указатели и константы

Указатели или указываемые ими объекты могут быть объявлены с модификатором const. Присвоение объекту, объявленномукак const, не допускается. Также не допускается создание указателя, который может нарушить запрещение на модификацию объекта типа константы. Рассмотрим следующие примеры:

int i; // i это целое;

int * pi; // pi это указатель на i

// (неинициализированный)

int * const cp = &i; // cp это указатель-константа на int

// const

int ci = 7; // ci это константа int const

int * pci; // pci это указатель наконстанту ci

const int * const cpc = &ci; // cpc это указатель-константа

// на константу int

Следующие присвоения допустимы:

i = ci; // Присвоить const int переменной int

*cp = ci; // Присвоение const int объекту, на

// который указывает

// указатель-константа

++pci; // Инкремент указателя на константу

pci = cpc; // Присвоение константы-указателя-на

// константу указателю-на-константу

Следующие присвоения недопустимы:

ci = 0; // Присвоение значений константе

// const int недопустимо

ci--; // Изменение константы недопустимо

*pci = 3; // Присвоение объекту, на который

// указывает указатель-на-константу

// недопустимо

cp = &ci; // Присвоение константе-указателю,

// даже если ее значение не будет

// изменено, недопустимо

cpc++; // Изменять указатель-константу

// недопустимо

pi = pci; // Если бы такое присвоение было

// разрешено, вы могли бы присваивать

// *pci (константе), присваивая *pi

// что недопустимо

Аналогичные правила относятся и к модификатору

volatile.Отметим, что const и volatile могут появляться в

качестве модификаторов одного и того же идентификатора.

Арифметические операции с указателями

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

Арифметические операции с указателями ограничены

сложением, вычитанием и сравнением. Арифметические операции

с указателями объектов типа "указатель на тип type" автоматически учитывают размер этоготипа, то есть число байт, необходимое для хранения в памяти объекта данного типа.

При выполнении арифметических операций с указателями предполагается, что указатель указывает на массив объектов. Таким образом, если указатель объявлен как указатель на type, то прибавление к нему целочисленного значения перемещает указатель на соответствующее количество объектов type. Если type имеет размер 10 байтов, то прибавление целого числа 5 к указателю этого типа перемещает указатель в памяти на 50 байт. Разность представляет собой число элементов массива, разделяющих два значения указателей. Например, если ptr1 указывает на третий элемент массива, а ptr2 на десятый, то результатом выполнения вычитания ptr2 - ptr1 будет 7э

Когда с "указателем на тип type" выполняется операция сложения или вычитание целого числа, то результат также будет "указателем на тип type". Ецли type неявляется массивом, то операнд указателя будет рассматриваться как указатель на первый элемент "массива типа type" длиной sizeof(type).

Конечно, такого элемента, как "указатель на следующий за последним элемент", однако указатель может принимать это значение. Если P указывает на последний элемент массива, то значение P+1 допустимо, но P+2 неопределено. Если P указывает на элемент за последним элементом массива, то допустимо значение P-1, когда указатель установлен на последний элемент массива. Однако установка указателя на элемент за последним элементом массива ведет к непредсказуемым результатам работы программы.

Для информации:P+n можно представить себе как перемещение указателя на (n*sizeof(type)) байт вперед, пока указатель остается в допустимых границах (не далее первого за концом массива элемента).

Вычитание междудвумя указателями на элементы одного и того же массива дает интегральное значение типа ptrdiff_t, определенное в stddef.h (signed long для указателей huge и far; signed intдля всех прочих). Данное значение представляет собой разность между индексами двух указанных элементов, при условии вхождения в диапазоне ptrdiff_t. В выражении P1P2, где P1 и P2 это указатели на тип type (или указатели на квалифицированный тип), P1 и P2 должны указывать на существующие элементы или на следующий за последним элемент. если P1 указывает на i-й элемент, а P2 указывает на j-й элемент, то P1-P2 имеет значение (i-j).

Преобразования указателей

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

char *str

int *ip

str = (char*)ip;

В более общем виде, приведение (type*) преобразует указатель в тип "указатель на тип type".

Объявления ссылок в С++

Ссылочные типы С++ тесно связаны с типами указателей. Ссылочные типы создают алиасы объектов и позволяют передавать функциям аргументы по ссылке. Традиционно передача аргументов в С выполняется только по значению. В С++ передавать аргументы можно как по значению, так и по ссылке. Полную информацию см. в разделе "Ссылки" на стр.98 оригинала.

Массивы

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

Объявление

type декларатор [<выражение-типа-константы>]

объявляет масив, состоящий из элементов типа type. Массив в С состоит из непрерывной области памяти, по размеру позволяющей в точности разместить все его элементы.

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

Многомерные массивы создаются путем объявления массивов из элементов типа массив. Таким образом, двумерный массив из пяти строк и семи столбцов с именем alpha объявляется следующим образом:

type alpha [5] [7];

В определенном контексте первый декларатор массива из нескольких может не иметь выражения в квадратных скобках. Такой массив имеет неопределенный размер. Контекстом, где допустимо такое положение, является тот случай, когдадля резервирования памяти размер массива не требуется. Например, для объявление объекта типа массива extern точный размер массива не требуется; не требуется он и при передаче функции параметра типа массива. Будучи специальным расширением ANSI C, Turbo C также позволяет объявлятьв качестве последнего элемента структуры массив неопределенного размера. Такой массив не увеличивает размера структуры, а для того, чтобы обеспечить правильное выравнивание структуры, ее можно специально дополнить символами-заполнителями. Такие структуры обычно используются при динамическом распределении памяти, когда для правильного резервирования области памяти к размеру структуры следует явно прибавить фактический размер необходимого массива.

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

Функции

Функции представляют собой центральный вопрос программирования на Turbo C++. Такие языки программирования, как Паскаль, делают различие между процедурами и функциями. В Turbo C++ функции играют обе роли.

Объявления и определения

Каждая программа должна иметь одну внешнюю функцию main, содержащую точку входа в программу. Обычно функции объявляютсякак прототипы в стандартных или создаваемых пользователем файлах заголовка, либо в файлах программы. По умолчанию функции имеют тип extern, и доступ к ним возможен из любого файла программы. Функция может быть ограничена спецификатором класса памяти static (см. стр. 32 оригинала).

Функции объявляются в исходных файлах, либо делаются доступными при компоновке с откомпилированными библиотеками.

В С++ вы должны всегда пользоваться прототипами функции. Мы рекомендуем также всегда использовать их и в С.

Данная функция может быть объявлена в программе несколько раз, при условии, что эти объявлениясовместимы. Неопределяющие объявления функции, использующие формат прототипа функции предоставляют Turbo C++ детальную информацию о параметрах, что позволяет лучшее управление числом аргументов, контролем их типа и преобразованиями типов.

За исключением перегрузки функции в С++, допустимым является только одно объявление данной функции в программе. Объявления, если они имеются, должны соответствовать определению функции. (Существенным различием между определением и объявлением является то, что определение содержит собственно тело функции.)

Объявления и прототипы

В оригинальном стиле объявлений Кернигэна и Ритчи функция могла быть либо объявлена неявно, по ее вызову, либо явно:

<type> func()

где type - это опциональный тип возврата, по умолчанию равный int. Можно объявить функцию с любым типом возврата, за исключениемтипов массива или функции. Такой подход не позволяет компилятору контролировать соответствие типа или количества используемыхпри вызове функции аргументов объявлению.

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

<type> func(список-деклараторов-параметров)

При помощи IDE или опции компилятора командной строки можно разрешить выдачу следующего предупреждения: "Function called without a prototype" ("Функция вызывается без прототипа").

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

long lmax(long v1, long v2); /* прототип */

main()

(*

int limit = 32;

char ch = 'A';

long mval;

mval = lmax(limit,ch): /* вызов функции */

Поскольку данная программа имеет прототип функции для lmax, данная программа преобразовывает limit и ch к типу long по стандартным правилам присвоения, прежде чем поместить их в стекдля вызова lmax.Без прототипа функции limit и ch были бы помещены в стек как целое и символьное значения, соответственно; в этом случае стек, переданный lmax, не соответствовал бы по размеру и содержимому тому, что ожидает на входе lmax, что привело бы к возникновению проблем. Классический стиль объявлений не позволяет выполнять контроль типа и числа параметров, поэтому использование прототипов функций существенно упрощает отслеживаниепрограммных ошибок.

Прототипы функций также упрощают документирование кодов программы. Например, функция strcpy принимает два параметра: исходную строку и строку назначения. Вопрос, где какая из них? Прототип функции

char *strcpy(char *dest, char *source);

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

Декларатор функции в круглых скобках, содержащий единственное словоvoid, указывает на функцию, вообще не принимающую аргументов:

func(void);

В С++ func() также означает функцию, не принимающую аргументов.

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

Прототип функции обычно объявляет функцию, принимающую фиксированное число параметров. Для функции С, принимающей переменное число параметров (например, printf) прототип функции может заканчиваться многоточием (...), например:

f(int *const, long total, ...)

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

Ниже приводятся примеры деклараторов функций и прототипы:

int f(); /* В С это функция, возвращащая int, без информации о параметрах. Это "классический стиль" Кернигэна и Ритчи */

int f(); /* В С++ это функция, не принимающая аргументов */

int f(void); /* Функция, возвращающая int и не принимающая параметров */

int p(int,long) /* Функция с типомвозврата int,принимающая два параметра, первый типа int, и второй типа long */

int pascal q(void); /* функция типа pascal, возвращающая int и не принимающая параметров */

char far *s(char *source, int kind); /* Функция, возвращающая дальний указатель на char и принимающая два параметра: превый - дальний указатель на char, а второй int */

int printf(char *format,...); /* Функция, возвращающая int и принимающая фиксированный параметр типа указатель на char и любое число дополнительных параметров неизвестного типа */

int (*fp)(int); /* Указатель на функцию, возвращающую int и принимающую один параметр int */

Объявления

Общий синтаксис для определений внешних функций приводится в следующей таблице:

Определения внешних функций Таблица 1.18

файл:

внешнее-определение

файл внешнее-определение

внешнее-определение:

определение-функции

объявление

asm-оператор

определение-функции:

<спецификаторы-объявления> декларатор <список-объявления>

составной-оператор

В целом, определение функции состоит из следующих разделов (грамматика позволяет создание и более сложных конструкций):

1. Опциональные спецификаторы класса памяти: extern или static. Умолчанием является extern.

2. Тип возврата, возможно void. Умолчанием является int.

Элементы из пунктов 1 и 2 можно взаимно комбинировать.

3. Опциональные модификаторы: pascal, cdecl, interrupt, near, far, huge. Умолчание зависит от модели памяти и установленных опций компилятора.

4. Имя функции.

5. Список объявления параметров, который может быть пустым, заключенный в круглые скобки. В с предпочтительно обозначать отсутствие параметров записью func(void). В С допускается и старый стиль записи func(), но это может приводить к неоднозначностям и возможным ошибкам. В С++ выдается соответствующее предупреждение.

6. Тело функции, представляющее собой коды, выполняемые при вызове функции.

Объявления формальных параметров

Список объявления формальных параметров имеет синтаксис, аналогичный синтаксису обычных объявлений идентификаторов. ниже приводится несколько примеров:

int func(void) (* // аргументы отсутствуют

С++int func(T! t1, T2 t2, T3 t3=1) (*

// три простых параметра,

// один из которых с аргументо

// по умолчанию

C++int func(T1* ptr1, T2& tref) (*

// аргументы указатель и ссылк

int func(register int i) (* // запрос регистра для аргумен

int func(char *str,...) (* /* один строковый аргумент ипеременное число прочих аргументов, либо фиксированное число аргументов с переменными типами */

В С++ вы можете задавать, как показано, аргументы по умолчанию. Параметры со значениями по умолчанию должны являться последними параметрами в списке. Типы аргументов могут быть скалярными, структурами,объединениями, перечислимого типа, указателямиили ссылками на структуры или объединения, или указателями на функции или классы.

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

Все объявленные параметры автоматически получают контекст, а также длительность данной функции. Единственным допустимым для них классом спецификатора является register.

В деклараторах формальных параметров могут использоваться модификаторы const и volatile.

Вызовы функций и преобразования аргументов

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

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

1. Модификаторы языка для определения функции должны соответствовать модификаторам, используемым в объявлении функции, при всех вызовах функции.

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

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

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

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

Важное замечание

Если прототип функции не соответствует фактическому определению функции, Turbo C++ обнаружит это в том и том случае, когда определение содержится в той же единице компиляции, что и прототип. При создании библиотеки подпрограмм с соответствующим файлом заголовкапрототипов незабывайте включать этот файл при компиляции библиотеки, с тем, чтобы любые расхождения между прототипом и фактическими определениями функции были обнаружены. С++ обеспечивает при компоновке контроль типов, поэтому все различия между ожидаемыми и действительно заданными параметрами будут компоновщиком обнаружены.

Структуры

Инициализация структуры описана на стр.42 оригинала.

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

В С++ тип структуры рассматривается как тип класса (с определенными различиями: доступ по умолчанию устанавливается public, а умолчание для базового класса также public). Это позволяет организовывать более сложное управление компонентами структуры при помощи спецификаторов доступа С++: public (это умолчание), private и protected. Помимо данного опционального механизма управления доступом и упомянутых исключений, далее рассматриваемые синтаксис и применение структур относятся равно к структурам С и С++.

Объявление структур выполняется при помощи ключевого слова struct. Например,

struct mystruct (* ... *); // mystruct - это тег структуры

...

struct mystruct s, *ps, arrs[10];

/* s имеет тип структуры mystruct; ps это указатель на тип struct mystruct */

Структуры без тегов и определения типов (typedef)

Структуры без компонентов и компоненты объединений при инициализации игнорируются.

Если тег структуры опущен, то получается структура без тега. Такуюструктуру можно использовать для объявления идентификаторов в разделяемом запятыми списке-идентификаторов-структуры как имеющих данный тип структуры (или являющихся производными от него), но объявлять объекты этого типа дополнительно где-либо еще нельзя:

struct (* ...*) s, *ps, arrs[10]; //структура без тега

При объявлении структуры, как с тегом, так и без него, можно создать typedef:

typedef struct mystruct (* ... *) MYSTRUCT;

MYSTRUCT s, *ps, arrs[10]; // то же, что и

// struct mystruct s и т.д.

typedef struct (* ... *) YRSTRUCT; // тег отсутствует YRSTRUCT y, *yp, arry[20];

Обычно и тег, и typedef одновременно не нужны; вобъявлениях структуры может быть использован любой из них.

Объявления компонентов структуры

Список-объявления-компонентов вфигурных скобках объявляет типы и имена компонентов структуры при помощи синтаксиса декларатора, показанного в таблице 1.11 на стр.36 оригинала.

Компоненты структуры могут быть любого типа, за двумя исключениями

1. Тип компонента не может быть тот же, что и объявляемая в текущий момент структура:

struct mystruct (* mystruct s *) s1, s2;// недопустимо

Компонент структуры может являться указателем на объявляемую структуру, как в следующем примере:

struct mystruct (* mystruct *ps *) s1, s2; // так можно

Кроме того, структура может содержать ранее объявленные типы структур, объявляя вхождения объявленных ранее структур.

В С++ ключевое слово struct может быть опущено.

2. Кроме С++, компонент структуры нигде не может иметь тип "функция, возвращающая ...", но тип "указатель на функцию, возвращающую ..." допустим. В С++ struct может иметь компоненты-функции.

Структуры и функции

Функция может иметь возвращаемое значение типа структуры или указателя структуры.

mystruct func1(void); // func1() возвращает структуру mystruct

*func29void); // func2() возвращает указатель структуры

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

void func1 (mystruct s); // непосредственно

void func2 (mystruct *sptr); // через указатель

void func3 (mystruct &sref); // по ссылке (только С++) Доступ к компоненту структуры

Доступ к компонентам структур и объединений выполняется операторами выбора . и ->. Предположим, что объект имеет тип структуры S, а sptr это указатель на S. Тогда, если m это идентификатор типа M, объявленного в S, то выражения s.m и sptr->m имеют тип M и представляют объект m - компонент структуры s. Выражение s->sptr является удобным синонимом (* sptr).m.

Операция . называется прямым селектором компонента структуры; операция -> называется косвенным селектором компонента (или указателем) структуры; например,

struct mystruct (*

int i;

char str[21];

double d;

*) s, *sptr=&s;

...

s.i = 3; // присвоению члему i структуры mystruct s sptr->d = 1.23; // присвоение компоненту d структуры mystruct s

Выражение s.m является именуемым значением (lvalue), если s это не именуемое значение и s не имеет тип массива. Выражение sptr->m является именуемым выражением, если m не имеет тип массива.

Если структура B содержит поле, тип которого есть структура A, то доступ к компонентам A выполняется через два одновременно задаваемых селектора компонента структуры:

struct A (*

int j;

double x;

*)

struct B (*

int i;

struct A a;

double d;

*) s, *sptr;

...

s.i = 3; // присвоение компоненту i структуры B s.a.j = 2; // присвоение компоненту j структуры A sptr->d = 1.23; // присвоение компоненту d структуры B (sptr->).x = 3.14 // присвоение компоненту x структуры A

Каждое объявление структуры вводит уникальный тип структуры, поэтому в

struct A (*

int i,j;

double d;

*) a, a1;

struct B (*

int i,j;

double d;

*) b;

объекты a и a1 оба имеют тип struct A, но объекты a и b имеют различные типы структуры. Структурам может выполняться присваивание только в том случае, если и исходная структура, и структура назначения имеют один и тот же тип:

a = a1;// так можно; тип один и тот же, поэтому может быть // выполнено покомпонентное присвоение структур

a = b;// так нельзя; разные компоненты

a.1 = b.1; a.j = b.j; a.d = b.d; // однако присвоение можно // выполнять на уровне компонентов структуры

Выравнивание по границе слова

Память распределяется структуре покомпонентно, слева-направо, от младшего к старшему адресу памяти. В следующем примере

struct mystruct (*

int i;

char str[2];

double d;

*) s;

объект s занимает достаточное количество памяти для размещения 2- байтового целочисленного значения, 21-байтовой строки и 8-байтового значения типа double. Формат данного объекта в памяти определяется опцией Turbo C++ выравнивания по границе слова. Когда эта опция выключена (по умолчанию), s будет занимать 31 байт непрерывно. Если же включить выравнивание по границе слова опцией -a компилятора (или в диалоговом поле Options \! Compiler \! Code Generation), то Turbo C++ заполняет структуры байтами таким образом, что структура была выравнена по следующим правилам:

1. Структура должна начинаться по границе слова (четный адрес).

2. Любой не-символьный элемент будет иметь четное смещение в байтах относительно начала структуры.

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

Если опция выравнивания включена, топриведенный пример структуры имел бы добавленный перед double байт, и весь объект в целом занимал бы 32 байта.

Пространство имен структур

Имена тегов структур разделяют общее пространство имен стегами объединений и перечислимых данных (однако в С++ имена входящих в структуру перечислимых данных находятсяв другом адресном пространстве). Это означает, что в пределах одного контекста такие теги должны иметь уникальные имена. Однако, имена тегов не обязаны отличаться от идентификаторов, находящихся в трех других адресных пространствах: пространстве имен меток, пространстве (пространствах) имен компонентов и едином адресном пространстве (которое состоит из имен переменных, функций, имен typedef и нкмераторов).

Имена компонентов в пределах данной структуры или объединения лбязаны быть уникальными, но среди разных структур или объединений они могут совпадать. Например,

goto s;

...

struct s (* // так можно; теги и имена меток находятся в разных // адресных пространствах

int s; // так можно; теги, имена меток и имена компонентов // дятся в разных адресных пространствах

float s;// так нельзя: повторение имени компонентов структур *) s; // так можно; пространства имен переменных различны // В С++ это допустимо только если s не имеет

// конструктора.

union s (* // так нельзя: повторение имен в пространстве тегов int s; // так можно: новое пространство компонентов float f;

*) f; // так можно: пространство имен переменных

struct t (*

int s; // так можно: следующее пространство имен компоненто

...

*) s; // так нельзя: повторение имен переменных

Неполные объявления

Указатель структуры типа А допустим в объявлении другой структуры В до объявления структуры А:

struct A;// неполное объявление struct B (* struct A *pa *);

struct A (* struct B *pb *);

Первое объявление А называется неполным, поскольку в этой точке отсутствует определение А. В данной ситуации неполное объявление допустимо, поскольку в объявлении В размер А необязателен. Битовые поля

Структура можетсодержать любые комбинации битовых полей с данными других типов.

Целочисленные компоненты типа signed или unsigned можно объявить битовыми полями шириной от 1 до 16 бит. Ширина битового поля и его опциональный идентификатор задаются следующим образом:

спецификатор-типа <идентификатор-битового поля>:ширина;

где спецификатор-типа это char, unsigned char, int или unsigned int. Битовые поля располагаются с нижнего и кончая саршим битом слова. Выражение "ширина" должно быть задано и должно давать целочисленную константу со значением в диапазоне от 0 до 16.

Если идентификатор битового поля опущен, то число битов, заданное выражением "ширина", распределяется в памяти, но поле при этом остается недоступным программе. Это позволяет создавать битовые шаблоны для, например, аппаратных регистров компьютера, в которых некоторые биты не используются. Пример:

struct mystruct (*

int i:2;

unsigned j:5;

int :4;

int k:1;

unsigned m:4;

*) a, b, c;

создает следующее распределение памяти.

\!

\! 15\!

4 \! 3 \!

14\! 13\! 12\! 11\! 2 \! 1 \! 0 \!

10\!

9

\

8

\!

7

\!

6

\!

5

\!

\! x \!

x \! x \!

x \! x \! x \! x \!

x \! x \! x \!

x \!

x

\

x

\!

x

\!

x

\!

x

--

\!<----

->\!<----

-------->\!<->\!<---

>\!

----

-

-

>\

<-

-

--

-

--

-

\

m \! k \

не используется\!

j

\

i

\!

Целочисленные поля хранятся в виде дополнения до двух, причем крайний левый бит побещается в MSB (наиболее значащий бит).Для битового поля типа Int (например, signed) MSB интерпретируется как знаковый бит. Битовое поле шириной 2, содержащее двоичное 11, будет, следовательно, в случае типа unsigned интерпретироватьсякак 3, а в случае Int как -1. В предыдущем примере допустимое выражение a.i = 6 поместит в a.i двоичное 10 = -2, не выдавая каких-либо предупреждений. Поле k типа signed int шириной 1 может содержать только значения -1 и 0, так как битовый шаблон 1 будет интерпретирован как -1.

Примечание

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

Выражение &mystruct.x недопустимо, так как x это идентификатор битового поля, а никакой гарантии, что mystruct.x имеет адрес на границе байта, нет.

Объединения

Объединения соответствуют типам вариантных записей языков Pascal и Modula-2.

Типы объединений являются производными типами, разделяющими многие синтаксические и функциональные свойства типов структур. Главное отличие между ними состоит в том, что объединение позволяет быть "активным" одновременно только одному компоненту. Размер объединения равен таким образом размеру своего максимального компонента. Одновременно в памяти может находиться значение только одного компонента лобъединения. В следующем простом случае

union myunion (* /* тег объединения = myunion */

int i;

double d;

char ch;

*) mu, *muptr=&mu;

идентификатор mu типа union myunion может служить для хранения 2-байтового значения int, 8-байтового значения double или 1-байтового char, но одновременно - только одного из этих значений.

Обе операции sizeof(union myunion) и sizeof (mu) возвращают значение 8, но когда mu содержит объект типа int, то 6 байт остаются неиспользованными (туда помещаются символы-заполнители), а когда mu сщдержит объект типа char - то 7 байт. Доступ к компонентам объединения выполняетсяпри помощи селекторов компонента структуры (. и ->), но требуется соблюдать осторожность:

mu.d = 4.016;

printf("mu.d = %f\n",mu.d);// порядок: на дисплее mu.d = 4.016

printf("mu.i = %f\n",mu.i);// забавный результат ! mu.ср = 'A';

printf("mu.ch = %c\n",mu.ch); // порядок: на дисплее mu.ch = A

printf("mu.d = %f\n",mu.d); // забавный результат ! muptr->i = 3; printf("mu.i = %d\n",mu.i); // порядок: на дисплее mu.i = 3

Второй оператор printf допустим, поскольку mu.i целочисленного типа. Однако, битовая комбинация в mu.i соответствует части ранее присвоенного значения типа double и не даст как правило полезной целочисленной интерпретации.

При правильных преобразованиях указатель объединения может указывать на любые его компоненты, и наоборот.

Объявления объединений

Общий синтаксисобъявления объединений во многом напоминает синтаксис объявления структур. Различия состоят в следующем:

1. Объединения могут содержать битовые поля, но активным бывает только одно изних. Все они начинаются в начале объединения.

2. С++ : В отличие от структур С++, объединения С++ не могут использовать спецификаторы класса доступа:public, private и protected. Все поля объединения имеют доступ private.

3. Объединения инициализируются через компонент, объявленный первым

union local87 (*

int i;

double d;

*) a = (* 20*);

4. С++ : Объединение не может участвовать в иерархии класса. Оно не может являться производным от какого-либо класса или быть базовым классом. Объединение может иметь конструктор.

5. С++ : Анонимные объединения не могут иметь компоненты-функции.

Перечислимые данные

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

enum days (* sun, mon, tues, wed, thur, fri, sat *) anyday;

устанавливает уникальный интегральный тип, enum days, переменную anyday этого типа и набор нумераторов (sun,mon,...), которым соответствуют целочисленные константы.

Turbo C++ может хранить нумераторы в одном байте, если это позволяет диапазон значений нумераторов, когда выключена опция -b (по умолчанию она включена; это означает, что данные типа enum всегда int), но при использовании их в выражениях выполняется этих данных преобразования к типу int. Идентификаторы, используемые в списке нумераторов, неявно получают тип unsigned char или int, в зависимости от значений нумераторов. Если все значения могут быть представлены типом unsigned char, то это и будет типом каждого нумератора.

C++ В С переменной перечислимого типа может быть присвоено любое значение типа int - кроме этого, никакого контроля типа не выполняется. В С++ переменной перечислимого типа может присваиваться только значение одного из ее нумераторов. Таким образом,

anyday = mon; // так можно

anyday = 1; // так нельзя, даже хотя mon == 1

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

enum days payday, holiday; // объявление двух переменных

С++ В С++ ключевое слово enum можно опустить, если в пределах данного контекста имя days не дублируется.

Как и в случае объявлений struct и union, если далее переменные данного типа enum не требуются, тег может быть опущен:

enum (* sun, mon, tues, wed, thur, fri, sat *) anyday;

/* анонимный тип enum */

Подробное описание констант перечислимого типа см. на стр. 17 оригинала.

Нумераторы, перечисленные внутри фигурных скобок, называются перечислимыми константами. Каждой из них назначается фиксированное целочисленное значение. При отсутствии явно заданных инициализаторов первый нумератор (sun) устанавливается в ноль, а каждый последующий нумератор имеет значение на единицу больше, чем предыдущий (mon = 1, tue = 2 и т.д.).

При наличии явных интегральных инициализаторов вы можете установить один или более нумераторов в конкретные значения. Любые последующие имена без инициализаторов будут получать приращение в единицу. Например, в следующем объявлении

/* выражение инициализатора может включать в себя нумераторы, объявленные ранее */

enum coins (* penny = 1, tuppence, nickel = penny + 4, dime =10, quarter = nickel * nickel *) smallchange;

tuppence примет значение 2, nickel - значение 5, а quarter - значение 25.

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

Тип enum может участвовать во всех конструкциях,допускающих использование типов int.

enum days (* sun, mon, tues, wed, thur, fri, sat *) anyday;

enum days payday;

typedef enum days DAYS;

DAYS *daysptr; int i = tues; anyday = mon; // так можно

*daysptr = anyday; // так можно

mon = tues; // неверно: mon - это константа

Теги перечислимых типов разделяют пространство имен с тегами структур и объединений. Нумераторы разделяют пространство имен с обычными идентификаторами переменных:

int mon = 11;

(*

enum days (* sun, mon, tues, wed, thur, fri, sat *) anyday;

/* нумератор mon скрывает внешнее объявление int mon */ struct days (* int i, j;); // неверно: дублируется тег days

double sat; // неверно: переопределение sat

*)

mon = 12; // снова в контексте int mon

C++ В С++ нумераторы, объявленные в пределах класса,имеют контекст этого класса.

Выражения

В таблице 1.19 показано, каким образом комбинируются идентификаторы и операции для составления грамматически верных "фраз".

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

Выражения Turbo C++ Таблица 1.19

первичное-выражение:

литерал

псевдо-переменная

(выражение)

this (только С++)

:: идентификатор (только С++)

:: имя-функции-операции (только С++)

имя

литерал:

целочисленная-константа

символьная-константа

константа-с-плавающей-точкой

строка

имя:

идентификатор:

имя-функции-операции (только С++)

имя-функции-преобразования (только С++)

квалифицированное-имя (только С++)

квалифицированное-имя: (только С++)

имя-класса :: идентификатор

имя-класса :: имя-функции-операции

имя-класса :: имя-функции-преобразования

имя-класса :: имя-класса

имя-класса :: - имя-класса

постфиксное-выражение:

первичное-выражение

постфиксное-выражение[выражение]

постфиксное-выражение (<список-выражений>)

постфиксное-выражение (<список-выражений>) (только С++) постфиксное-выражение . имя постфиксное-выражение -> имя постфиксное-выражение ++ постфиксное-выражение --

список-выражений:

выражение-присваивания

список-выражений , выражение-присваивания

унарное-выражение:

постфиксное-выражение

++ унарное-выражение

-- унарное-выражение

унарная-операция выражение-приведения

sizeof унарное-выражение

sizeof (имя-типа)

выражение-распределения (только С++)

выражение-отмены-распределения (только С++)

унарная-операция: одно из

& * + - тильда !

выражение-распределения: (только С++)

<::> new <местоположение> имя-ограниченного-типа <инициализатор

<::> new <местоположение> имя-типа <инициализатор>

местоположение: (только С++)

(список-выражений)

имя-ограниченного-типа: (только С++)

спецификатор-типа <декларатор-ограничения>

декларатор-ограничения: (только С++)

операция-указателя <декларатор ограничения>

декларатор-ограничения [<выражение>]

выражение-отмены-распределения: (только С++)

<::> delete выражение-приведения

<::> delete [выражение] выражение-приведения

выражение-приведения:

унарное-выражение

(имя-типа) выражение-приведения

выражение-типа-ссылки:

выражение-приведения

выражение-типа-ссылки .* выражение-приведения (только С ++) выражение-типа-ссылки -> выражение-приведения (только С+ +)

выражение-типа-умножения:

выражение-типа-ссылки

выражение-типа-умножения * выражение-типа-ссылки

выражение-типа-умножения / выражение-типа-ссылки

выражение-типа-умножения % выражение-типа-ссылки

выражение-типа-сложения:

выражение-типа-умножения

выражение-типа-сложения + выражение-типа-умножения

выражение-типа-сложения - выражение-типа-умножения

выражение-типа-сдвига:

выражение-типа-сложения

выражение-типа-сдвига << выражение-типа-сложения

выражение-типа-сдвига >> выражение-типа-сложения

выражение-отношения:

выражение-типа-сдвига

выражение-отношения < выражение-типа-сдвига

выражение-отношения > выражение-типа-сдвига

выражение-отношения <= выражение-типа-сдвига

выражение-отношения >= выражение-типа-сдвига

выражение-типа-равенства:

выражение-отношения

выражение-типа-равенства = выражение-отношения

выражение-типа-равенства != выражение-отношения

выражение-И:

выражение-типа-равенства

выражение-И & выражение-типа-равенства

выражение-исключающее-ИЛИ:

выражение-И

выражение-исключающее-ИЛИ выражение-логическое-И

выражение-включающее-ИЛИ:

выражение-исключающее-ИЛИ

выражение-включающее-ИЛИ \! выражение-исключающее-ИЛИ

выражение-логическое-И:

выражение-включающее-ИЛИ

выражение-логическое-И && выражение-включающее-ИЛИ

выражение-логическое-ИЛИ:

выражение-логическое-И

выражение-логическое-ИЛИ !! выражение-логическое-И

условное-выражение:

выражение-логическое-ИЛИ

выражение-логическое-ИЛИ ? выражение : условное-выражение

выражение-присвоения:

условное-выражение

унарное-выражение операция-присвоения выражение-присвоения

операция-присвоения: одно из

= *= /=%= += -=

<<= ??= &=^= \!=

выражение:

выражение-присвоения

выражение, выражение-присвоения

выражение-типа-константы:

условное-выражение

Стандартные преобразования подробно рассматриваются на стр.42 оригинала, в таблице 1.15.

Вычисление выражений выполняется по определенным правилам преобразования, группировки, ассоциативности и приоритета, которые зависят от используемых в выражениях операций, наличию круглых скобок и типов данных операндов. Способ группировки операндов и подвыражений не обязательно определяет фактический порядок вычисления выражений в Turbo C++ (см. "Последовательность вычислений" на стр. 76 оригинала.)

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

Грамматические правила, приведенные в таблице 1.19, на стр. 74 оригинала, полностью определяют приоритеты и ассоциативность операций. Кратко эта информация сведена в таблице

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

Ассоциативность и приоритеты операций Turbo C++ Tаблица 1.20

Операции Ассоциативность

() [] -> :: . Слева-направо

! тильда - ++ -- & * Справа-налево

sizeof new delete .* ->* / % Слева-направо

+ - Слева-направо

<< >> Слева-направо

< <= > >= Слева-направо

& Слева-направо

^ Слева-направо

\! Слева-направо

&& Слева-направо

\!\! Слева-направо

?:условное выражение Справа-налево

= += /= %= += -= Справа-налево

&= ^= \!= , Слева-направо

Приоритеты обозначаютсяпоследовательностью расположения в данной таблице. Первый элемент таблицы имеет наивысший приоритет.

Выражения и Turbo C++

С++ позволяет перегрузку некоторых стандартных операций С, как описано начиная со стр.125 оригинала. Перегруженной называется такая операция, которая применительно к выражениям типа класса ведет себя некоторым специальным образом. Например, оператор отношения == может быть определен в классе complex для проверки равенства двух комплексныхчисел, причем действие его для типов данных других классов остается прежним. Перегруженный оператор реализуется как функция; эта функция определяет тип операнда, именующее выражение (lvalue) и последовательность вычислений, устанавливаемая при использовании перегруженного оператора. Однако, перегрузка не может изменять приоритеты операций. Аналогичным образом, С++ позволяет выполнять определяемые пользователем преобразования между объектами класса и фундаментальными типами. Учтите, что некоторые правила относительно операций и преобразований, обсуждаемые в данном разделе, неприменимы к выражениям в С++.

Последовательность вычислений

Последовательность вычисления операндов в выражениях Turbo C++ не определена, если иное явно не задано операцией. Компилятор пытается реорганизовать выражение таким образом, чтобы улучшить качество генерируемого кода. Следовательно, необходима осторожностьпри работе с выражениями, в которых значение модифицируется более одного раза. В целом,следует избегать создания выражений, которые одновременно и модифицируют, и используют значение одного и того же объекта. Рассмотрим выражение

i = v[i++]; // i неопределено

Значение i зависит от того, выполняется ли инкрементирование до или после присвоения. Аналогичным образом,

int total = 0;

sum = [total = 3] + (++total);// sum = 4 или sum = 7 ??

имеет неоднозначность идентификаторов sum и total. Решение состоит в том, чтобы упростить выражение при помощи временной переменной:

int temp, temp = 0;

temp = ++total;

sum = (total = 3) + temp;

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

sum = (i = 3, i++, i++); // так можно: sum = 4, i = 5

Каждое под-выражение или выражение с запятыми вычисляется слева-направо, и все выражение в целом вычисляется понаправлению к самому правому значению.

Turbo C++ перегруппирует выражения, реорганизовывая ассоциативные и коммутативные операции независимо от наличия круглых скобок, с тем, чтобы получить эффективно компилируемое выражение; реорганизация выражения ни в коем случае не влияет на результатвычисления выражения.

Круглые скобки можно использовать для того, чтобы принудительно задать порядок вычислений в выражении. Например, если имеются переменные a, b, c и f, то выражение f=a+(b+c) вызывает сначала вычисление (b+c), а затем уже сложение результата с a.

Ошибки и переполнения

Во время вычисления выражения Turbo C++ может встретить многие проблематичные ситуации, как то деление на ноль или получение значений с плавающей точкой, выходящих за пределы допустимого диапазона. Переполнение целочисленных значений игнорируется (С использует арифметические действия по модулю 2 в n-разрядных регистрах), однако ошибки, обнаруживаемые математическими библиотечными функциями, могут обрабатываться стандартными или определяемыми пользователем подпрограммами. См. matherr и signal в Справочнике по Библиотеке.

- 76 -

Семантика операций

Описанные здесь операции Turbo C++ являются операциями стандарта ANSI C.

Если операции не перегружены, то следующая информация действительна как для С, так и для С++. В С++ вы можете перегрузить все эти операции, за исключением операции . (операция задания компонента) и ?: (условная операция) (также не могут быть перегружены операции С++ :: и .*).

Если операция перегружена, то приводимые здесь сведениядля нее недействительны.Таблица 1.19 на стр.74 оригинала приводит синтаксис для всех операций и выражений с операциями.

Постфиксные и префиксные операции

Шесть постфиксных операций [] () . -> ++и -- используются для построения постфиксных выражений, показанных в таблице синтаксиса выражений (таблица 1.19). Операции инкремента и декремента (++ и --) также являются префиксными и унарными операциями;они обсуждаются, начиная со стр.79 оригинала.

Операция индексации массива [] --------------------------

В выражении

постфиксное-выражение [выражение]

в С, но не обязательно в С++, выражение выраж1[выраж2] определяется как

*((выраж1) + (выраж2))

где либо выраж1 это указатель, а выраж2 это целочисленное значение, либо выраж1 это это целочисленное значение, а выраж1 это указатель. (Каждый из пунктуаторов [], * и + может быть перегружен в С++).

Операция вызова функции ()

Выражение

постфиксное-выражение(<список-аргументов-выражения>)

представляет собой вызов функции, задаваемой постфиксным выражением. Список-аргументов-выражения - это разделяемый запятой список выражения любого типа, задающий фактические (или действительные) аргументы функции. Значение самого выражения вызова функции, если оно вообще имеет место, определяется оператором возврата в определении функции. См. "Вызовы функций и преобразования аргументов" на стр.63 оригинала, где приводится более поробное изложение вызова функций.

Операция задания компонента структуры/объединения . (точка)

В выражении

постфиксное-выражение . идетификатор

постфиксное-выражениедолжно иметь тип структуры или объединения; идентификатор должен являться именем компонента данной структуры или объединения. Выражение обозначает объект - компонент структуры или объединения. Значением данного выражения будет являться значение выбранного таким образом компонента; оно будет являться именующим выражением (lvalue) в том и только том случае, если именующим выражением является само постфиксное выражение. Подробное описание использования операций . и -> дается на стр.66 оригинала.

Именующие выражения определяются на стр.28 оригинала.

Операция указателя структуры/объединения ->

В выражении

постфиксное-выражение -> идентификатор

должно иметьтип указателя структуры или указателя объединения; идентификатор же должен быть именем компонента этой структурыили объединения. Выражение обозначает объект - компонент структуры или объединения. Значением данного выражения будет являться значение выбранного таким образом компонента; оно будет являться именующим выражением (lvalue) в том и только том случае, если именующим выражением является само постфиксное выражение.

Операция постфиксного инкремента ++

В выражении

постфиксное-выражение++

операндом является постфиксное выражение:

оно должно быть скалярного типа (арифметического или типа указателя) и должно являться модифицируемым именующим выражением (более подробная информация об именующих выражениях приводится на стр.28 оригинала.) Постфикс ++ также называют операцией постинкремента. Значением всего выражения является значение постфиксного выражения до выполнения инкремента. После вычисления постфиксного выражения операнд инкрементируется на 1.

Величина инкремента зависит от типа операнда. Значения типа указателя вычисляются по правилам арифметических действий с указателями.

Постфиксная операция декремента --

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

Операции инкремента и декремента

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

Операция префиксного инкремента ++

В выражении

++ унарное-выражение

операндом является унарное выражение:

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

Префиксная операция декремента --

Префиксная операция декремента, также известная как предекремент, имеет следующий синтаксис:

--унарное-выражение

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

Унарные операции

Существует шесть унарных операций (кроме ++ и --): . * + - тильда и !. Их синтаксис:

унарная-операция выражение-приведения

выражение-приведения:

унарное-выражение

(имя-типа) выражение-приведения

Операция адресации &

Символ & также используется в С++ для задания ссылочных типов данных. См. стр.98 оригинала.

Операции& и * (операция * описана в следующем разделе) используются совместно в качестве операций установки ссылки и ображения по ссылке (разыменования). В выражении

& выражение-приведения

операнд выражение-приведениядолженявляться либо обозначением функции, либо именующим выражением, обозначающим объект, не являющийся битовымполем и не имеющий спецификатор класса памяти register. Если операнд имеет некоторый тип type, то результатом операции будет указатель на type.

Отметим, что некоторые не являющиеся именующим выражением идентификаторы, такие как имена функций и имена массивов, автоматически преобразовываются в определенном контексте к типу "указатель на X". Операцию & использовать с такими объектами можно, но такая операция будет являться избыточной и будет отменена компилятором.

Рассмотрим следующий фрагмент:

type t1 =1, t2 = 2;

type *ptr = &t1; // инициализированный указатель

*ptr = t2; // тот же эффект, что и t1 = t2

Отметим, что type *ptr = &t1 обрабатывается как

T *ptr; ptr = &t1;

так что присваивается не *ptr, а ptr. После инициализации ptrадресом&t1 его можно использовать для обращения по ссылке и получить именующее выражение *ptr.

Операция обращения по ссылке *

В выражении

* выражение-приведения

операнд выражение-приведения должен иметь тип "указатель на type", где type это любой тип. Результатом обращения по ссылке имееттип type.Если операнд имеет тип "указатель функции", то результатом будет являться обозначение функции; если операндом является указатель на объект, то результатом будет именующее выражение, обозначающее данный объект. В следующих ситуациях результат обращения по ссылке неопределен:

1. Выражение-приведения это пустой (null) указатель.

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

Унарная операция плюс +

В выражении

+выражение-приведения

операнд выражение-приведения должен быть

арифметического типа. Результатом является значение операнда

после любых требуемых интегральных действий.

Унврная операция минус -

В выражении

-выражение-приведения

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

Операция поразрядного дополнения (тильда)

В выражении

<тильда>выражение-приведения

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

Операция логического отрицания !

В выражении

!выражение-приведения

операнд выражение-приведения должен быть скалярного типа. Результат иммет тип int и представляет собой логическое отрицание операнда: 0 при ненулевом операнде и 1 в случае нулевого операнда. Выражение !E эквивалентно выражению (0 ==

Е).

Операция sizeof

Существует два раздельных способа использования операции sizeof:

sizeof унарное-выражение

sizeof (имя-типа)

Размер выделяемой для каждого типа памяти зависит от конкретной машины.

В обоихсучаяхрезультат представляет собой целочисленную константу, выражающую размер в байтах областипамяти, занимаемой операндом (определяемый за некоторыми исключениями типом операнда). В первом случае тип выражения операнда определяется без расчета выражения (и следовательно, без побочных эффектов). Если операнд имеет тип char (signed или unsigned), то операция sizeof дает в результате1. Если операнд не является параметром и имеет тип масива, то результат представляет собой общее количество байтов в массиве (другими словами, имя массива не преобразовавается к типу указателя). Число элементов массива равно sizeof массив/sizeof массив[0].

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

Целочисленный тип результата операцииsizeof называется size_t, определенный как unsigned int в stddef.h.

Можно использовать sizeof в директивах препроцессора; это особенность Turbo C++.

C++: В С++ sizeof(тип класса), где тип класса является производным от какого-либо базового класса, возвращает размер базового класса.

Операции типа умножения

Существует три операции типа умножения: * / и %. Синтаксис этих операций следующий:

выражение-типа-умножения:

выражение-приведения

выражение-типа-умножения * выражение-приведения

выражение-типа-умножения / выражение-приведения

выражение-типа-умножения % выражение-приведения

Операнды операций * (умножения) и / (деления) должны быть арифметического типа. Операнды операции % (деление по модулю,или остаток) должны быть интегрального типа. С операндами выполняются обычные арифметические преобразования (см. стр.41 оригинала).

Результатом выполнения операции (операнд1 * операнд2) является произведение двух операндов. Результатами операций (операнд1 / операнд2) и (операнд1 % операнд2) являются частное и остаток от деления, соответственно, где операнд1 делится на операнд2, при условии, что операнд2 не равен нулю. Использование операций / и % с нулевым делителем дает ошибку.

Если операнд1 и операнд2 имеют целочисленный тип, а частное не является целым, то результаты операции следующие:

1. Если операнд1 и операнд2 имеют одинаковый знак, то операнд1/ операнд2 есть наибольшее целое, меньшее чем истинное частное, а операнд1 % операнд2 имеет тот же знак, что и операнд1.

2. Если операнд1 и операнд2 имеют разные знаки, то операнд1/ операнд2 есть наименьшее целое, большее чем истинноечастное, а операнд1 % операнд2 имеет тот же знак, что и операнд1.

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

Операции типа сложения

Существует две операции типа сложения: + и -. Синтаксис этих операций следующий:

выражение-типа-сложения:

выражение-типа-умножения

выражение-типа-сложения + выражение-типа-умножения

выражение-типа-сложения - выражение-типа-умножения

Операция сложения +

Допустимыми являются следующие типы операндов выражения операнд1 + операнд2:

1. Операнд1 и операнд2 оба арифметического типа.

2. Операнд1 интегрального типа, а операнд2 является указателем на объект.

3. Операнд2 интегрального типа, а операнд1 является указателем на объект.

В первом случае выполняются стандартные арифметические преобразования операндов, а результатом является их арифметическая сумма. В случаях 2 и 3 применяются правила арифметических действий с указателями. (Арифметические действия с указателями рассматриваются на стр.57 оригинала).

Операция вычитания -

Допустимыми являются следующие типы операндов выражения операнд1 - операнд2:

1. Операнд1 и операнд2 оба арифметического типа.

2. Оба операнда являются указателями на совместимые типы объектов. (Примечание: неквалифицированный тип type рассматривается как совместимый с квалифицированными типами const type, volatile type и const volatile type.)

3. Операнд2 интегрального типа, а операнд1 является указателем на объект.

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

Операции поразрядного сдвига

Существует две операции поразрядного сдвига: << и >>. Синтаксис этих операций следующий:

выражение-типа-сдвига:

выражение-типа-сложения

выражение-типа-сдвига << выражение типа сдвига

выражение-типа-сдвига >> выражение типа сдвига

Операция поразрядного сдвига влево <<

В выражении E1 << E2 операнды Е1 и Е2 должны иметь тип int. С Е1 и Е2 выполняются обычные целочисленные действия, а тип результата определяется операндом Е1. Если Е2 отрицателен, либо по числу разрядов больше или равен Е1, то операция неопределена.

Результатом операции E1 << E2 является значение E1, сдвинутое влево на Е2 разрядов и при необходимости заполненное справа нулями. Сдвиг влево unsigned long E1 эквивалентно умножению Е1 на 2 в степени Е2 и редуцированию по модулю ULONG_MAX+1; сдвиг влево unsigned int эквивалентно умножению на 2 в степени Е2 и редуцированию по модулю UINT_MAX+1. Если Е1 это signed int, то результат следует интерпретировать с осторожностью, поскольку знаковый бит изменился.

Константы ULONG_MAX и UINT_MAX определяются в .h-файле.

Операция поразрядного сдвига вправо >>

В выражении E1 >> E2 операнды Е1 и Е2 должны иметь тип int. С Е1 и Е2 выполняются обычные целочисленные действия, а тип результата определяется операндом Е1. Если Е2 отрицателен, либо по числу разрядов больше или равен Е1, то операция неопределена.

Результатом операции E1 >> E2 является значение E1, сдвинутое вправо на Е2 разрядов. Если Е1 имеет тип unsigned, то при необходимости происходит его заполнение нулями слева. Если же Е1 имеет тип signed, то заполнение слева выполняется знаком (0 для положительных и 1 для отрицательных значений). Такое расширение знакового бита гарантирует, что знак у Е1 >> E2 будет таким же, как и у E1. За исключением типов со знаком, значение E1 >> E2 представляет собой целую часть частного.

Операции отношения

Существует четыре операции отношения: < > <= и >=. Синтаксис этих операций следующий:

выражение-отношения:

выражение-типа-сдвига

выражение-отношения < выражение-типа-сдвига

выражение-отношения > выражение-типа-сдвига

выражение-отношения <=выражение-типа-сдвига

выражение-отношения >=выражение-типа-сдвига

Операция меньше чем <

В выражении E1 < E2 операнды должны удовлетворять одному из следующего набора условий:

1. Оба значения Е1 и Е2 - арифметического типа.

2. Оба значения Е1 и Е2 являются указателями квалифицированных или неквалифицированных версий совместимых типов объектов.

Определение квалифицированных имен дается на стр.108 оригинала.

3. Оба значения Е1 и Е2 являются указателями квалифицированных или неквалифицированных версий совместимых неполных типов.

В случае 1 выполняются обычные арифметические преобразования. Результат E1 < E2 имеет тип int. Если значение E1 меньше значения E2, то результат равен 1 (истина); в противном случае результат равен 0 (ложь).

В случаях 2 и 3, где Е1 и Е2 являются указателями совместимых типов, результат операции E1 <E2 зависит от относительного расположения (адресов) двух указываемых ими объектов. При сравнении компонентов одной и той же структуры "старший" указатель обозначает более позднее объявление. В массивах "старший" указатель обозначает большее значение индекса массива. Сравнение указателей компонентов одного объединения дает равенство.

Обычно сравнение указателей разных структур, массивов или объединений , либо сравнение указателей вне диапазона объекта типа массив дает неопределенные результаты; однако исключение делается для указателя "за последним элементом", как указывается в разделе "Арифметические действия с указателями" на стр.57 оригинала. Если Р указывает на элемент массива, а Q указывает на его последний элемент, то выражение H<Q+1 допустимо и дает 1 (истина), хотя Q+1 и не указывает на какой-либо элемент этого массива.

Операция больше чем >

Выражение E1 > E2 дает 1 (истина), если значение Е1 больше значения Е2;в противном случае результат равен 0 (ложь), причем используются те же способы интерпретации арифметических сравнений и сравнений указателей, что определены для операции "больше чем". К операндам применимы те же правила и ограничения.

Операция меньше или равно <=

Аналогичным образом, выражение E1 <= E2 дает 1 (истина), если значение Е1 меньше или равно значению Е2. В противномслучаерезультат равен 0 (ложь), причем используются те же способы интерпретации арифметических сравнений и сравнений указателей, что определены для операции "меньше чем". К операндам применимы те же правила и ограничения.

Операция больше или равно >=

И наконец, выражение E1 >= E2 дает 1 (истина), если значение Е1 больше или равно значению Е2. В противном случае результат равен 0 (ложь), причем используются те же способы интерпретации арифметических сравнений и сравнений указателей, что определены для операции "меньше чем". К операндам применимы те же правила и ограничения.

Операции типа равенства

Существует две операции типа равенства: == и !=. Они проверяют условие равенства операндов арифметического типа и типа указателей, следуя при этом правилам, аналогичным тем, что действуют для операцийотношения. Отметим, однако, что == и != имеют более низкий приоритет выполнения, чем операции отношения <, >, <= и >=. Кроме того, операции == и != позволяют выполнять проверку равенства указателей в таких случаях, где операции отношения неприменимы. Синтаксис этих операций следующий:

выражение-типа-равенства:

выражение-отношения

выражение-типа-равенства == выражение-отношения

выражение-типа-равенства != выражение-отношения

Операция проверки равенства ==

В выражении E1 == E2 операнды должны удовлетворять одному из следующего набора условий:

1. Оба значения Е1 и Е2 - арифметического типа.

2. Оба значения Е1 и Е2 являются указателями квалифицированных или неквалифицированных версий совместимых типов.

3. Одно из значений, Е1 или Е2, является указателем объекта неполного типа, а второй - указателем на квалифицированную или неквалифицированную версию void.

4. Одно из значений, Е1 или Е2, является указателем, а второе - константой типа пустого указателя.

Если Е1 и Е2 имеют тип, являющийся допустимым типом для операций отношения, то применимы правила, подробно описанные для операций отношения типа Е1 < E2, E1 <= T2, и т.д.

В случае 1, например, выполняются обычные арифметические преобразования, а результат операции Е1 == Е2 имеет тип int. Если значение Е1 равно значению Е2, то результат равен 1 (истина); в противном случае результат равен нулю (ложь).

В случае 2 Е1 == Е2 дает 1 (истина), если Е1 и Е2 указывают на один и тот же объект, либо оба указывают на "следующий после последнеего" элемент одного и того же объекта типа массив, либо оба являются пустыми указателями.

Если Е1 и Е2 являются указателями на объекты типа функции, то Е1 == Е2 дает значение 1 (истина), если оба они пустые, либо оба указывают на одну и ту же функцию. И наоборот, если Е1 == Е2 дает 1 (истина), то и Е1, и Е2 указывают на одну и ту же функцию или являются пустыми.

В случае 4 указатель объекта или неполного типа преобразуется к типу другого операнда (указателю квалифицированной или неквалифицированной версии void).

Оператор проверки неравенства !=

Выражение Е1 != Е2 подчиняется тем же правилам, что и ля Е1 == Е2, за исключением того, что результат равен 1 (истина), если операнды неравны, и 0 (ложь) в случае равенства операндов.

Операция поразрядного И &

Синтаксис данной операции следующий:

выражение-И:

выражение-типа-равенства

выражение-И & выражение-равенства

В выражении E1& E2 оба операнда должны быть интегрального типа. Выполняются обычные арифметические преобразования Е1 и Е2, а результатом является поразрядное И для Е1 и Е2. Каждый бит результата определяется в соответствии с таблицей

1.21.

Таблица истинности для поразрядных операций Таблица 1.21

Битовое значение в Е1 в Е2

Битовое

значение

Е1

&

E2

E1

^

E2

E1

\!

E2

0 0 0 0

1 0 0 1

0 1 0 1

1 1 1 0

0

1

1

1

Операция поразрядного исключающего ИЛИ^

Синтаксис этой операции следующий:

выражение-исключающее-ИЛИ:

выражение-И

выражение-исключающее-ИЛИ ^ выражение-И

В выражении E1 ^ E2 оба операндадолжныбыть интегрального типа,причем выполняются обычные арифметические преобразования Е1 и Е2, а результатом операции является поразрядное исключающееИЛИ для Е1 и Е2. Каждый бит результата определяется таблицей 1.21.

Операция поразрядного включающего ИЛИ \!

Синтаксис этой операции следующий:

выражение-включающее-ИЛИ:

выражение-исключающее-ИЛИ

выражение-включающее-ИЛИ \! выражение-исключающее-ИЛИ

В выражении E1\! E2 оба операнда должны быть интегрального типа, причем выполняются обычные арифметические преобразования Е1 и Е2, а результатом операции является поразрядное включающее ИЛИ для Е1 и Е2. Каждый бит результата определяется таблицей 1.21.

Операция логического И&&

Синтаксис этой операции следующий:

выражение-логическое-И:

выражение-включающее-ИЛИ

выражение-логическое-И && выражение-включающее-ИЛИ

В выражении E1 && E2 оба операнда должны быть скалярноготипа. Результат операции имеет тип int и равен 1 (истина), если оба значения, Е1 и Е2 ненулевые; в противном случае результат равен 0 (ложь).

В отличие от поразрядной операции &, операция && гарантирует расчет выражения в последовательности слева-направо: первым вычисляется Е1; если Е1 равен 0, то Е1 && E2 дает 0 (ложь), и Е2 не вычисляется вообще.

Операция логического ИЛИ \!\!

Синтаксис этой операции следующий:

выражение-логическое-ИЛИ:

выражение-логическое-И

выражение-логическое-ИЛИ \!\! выражение-логическое-И

В выражении E1 \!\! E2 оба операнда должны быть скалярноготипа. Результат операции имеет тип int и равен 1 (истина), если одно из значений, Е1 или Е2 ненулевое; в противном случае результат равен 0 (ложь).

В отличие от поразрядной операции \!, операция \!\! гарантирует расчет выражения в последовательности слева-направо: первым вычисляется Е1; если Е1 не равен 0, то Е1 \!\! E2 дает 1 (истина), и Е2 не вычисляется вообще.

Условная операция ?:

Синтаксис этой операции следующий:

условное-выражение

выражение-логическое-ИЛИ

выражение-логическое-ИЛИ ? выражение : условное-выражение

В выражении Е1? Е2 : Е3 операнд Е1 должен быть скалярного типа. Операнды Е2 и Е3 должны удовлетворять одному из приводимых ниже правил:

1. Оба операнда - арифметического типа.

2. Оба операнда имеют совместимые типы структуры или объединения.

3. Оба операнда - типа void.

4. Оба операнда имеют тип указателя на квалифицированные или неквалифицированные версии совместимых типов.

5. Один операнд имеет тип указателя, а второй является константой типа пустого указателя.

6. Один операнд имеет тип указателя на объект или неполный тип, а второй - тип указателя на квалифицированную или неквалифицированную версию типа void.

Прежде всего вычисляется Е1; если он имеет ненулевое значение (истина), то Е2 вычисляется, а Е3 игнорируется. Если Е1 дает ноль (ложь), то Е3 вычисляется, а Е2 игнорируется.Результат операции Е1 ? Е2 : Е3 зависит от того, который из операндов, Е2 или Е3, будет вычисляться.

В случае 1 оба операнда, Е2 и Е3, подвергаются обычным арифметическим преобразованиям, а типом результата будетобщий тип, получаемый в результате преобразований.

В случае 2 типом результата будет являться общий тип структуры или объединения Е2 или Е3.

В случае 3 результат будет иметь тип void.

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

В случае 6 типом результата будет тип операнда, не являющегося указателем на void.

Операции присвоения

Существует одиннадцать операций присвоения. самым простым из них является операция =; остальные называются составными операциями присвоения.

Синтаксис операций присвоения следующий:

выражение-присвоения:

условное-выражение

унарное-выражение операция присвоения выражение-присвоения

операция-присвоения: одно из

= *= /= %= += -=

<<= >>= &= ^= \!=

Простая операция присвоения =

В выражении Е1 = Е2 Е1 должен быть модифицируемым именующим выражением. Значение Е2 после преобразования к типу Е1 помещается в объект, задаваемый Е1 (замещая предыдущее значение Е1). Значение выражнения присвоения это значение Е1 после присвоения. Само по себе выражение присвоения не является именующим значением.

ОперандыЕ1 и Е2 должны удовлетворять одному из следующего набора правил:

1. Е1 имеет квалифицированный или неквалифицированный арифметический тип, а Е2 имеет арифметический тип.

2. Е1 имеет квалифицированную или неквалифицированную версию типа структуры или объединения, совместимого с типом Е2.

3. Е1 и Е2 это указатели на квалифицированную или неквалифицированную версии совместимых типов , а тип, на который указывает левый операнд, имеет все квалификаторы типа, на который указывает правый операнд.

4. Один из операндов, Е1 или Е2, является указателем объектаили неполного типа, а другой - указвтелем на квалифицированную или неквалифицированную версию void. Тип, на который указываетлевый операнд, имеет все квалификаторы типа, на который указывает правый операнд.

5. Е1 является указателем, а Е2 - константой типа пустого указателя.

Составные операции присвоения

Составные операции вида операция=, где "операция" - это один из десяти символов операции * / % + - << >> & ^ \!, интерпретируются следующим образом:

Е1 операция= Е2

имеет тот же эффект, что и

Е1 = Е1 операция Е2

за исключением того, что именующее значение Е1 вычисляется только один раз. Например, Е1 += Е2 это то же самое, что Е1 = Е1 + Е2.

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

Операция с запятой

Синтаксис этой операции следующий:

выражение:

выражение-присвоения

выражение , выражение-присвоения

В выражении с запятой

Е1,Е2

левый операнд Е1 вычисляется как выражение void, затем Е2 вычисляется таким образом, что дает результат и тип выражения с запятой. Рекурсивно, выражение

Е1,Е2,...,Уn

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

func(i, (j = 1, j +4), k);

вызывает func с тремя аргументами, а не с четырьмя. Эти аргументы:

i, 5 и k.

Операторы

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

Операторы Turbo C++ Таблица 1.22

оператор:

оператор-с-меткой

составной-оператор

оператор-выражение

оператор-выбора

оператор-итерации

оператор-перехода

asm-оператор

объявление (только С++)

asm-оператор:

asm лексемы новая-строка

asm лексемы;

asm (*лексемы; <лексемы;>=

<лексемы;>

*)

оператор-с-меткой

идентификатор : операция

case выражение-типа-константы : оператор

default : оператор

составной-оператор:

(* <список-объявления> <список-операторов> *)

список-объявления:

объявление

список-объявления объявление

список-операторов:

<выражение>;

оператор-выбора:

if (выражение) оператор

if (выражение) оператор else оператор

switch (выражение) выражение

выражение-итерации:

while (выражение) оператор

do оператор while (выражение);

for (оператор-нач-условия <выражение> ; <выраже-

ние>)оператор

оператор-нач-условия:

оператор-выражение

объявление (только С++)

оператор-перехода:

goto идентификатор;

continue ;

break ;

return <выражение>;

Блоки

Составной оператор, или блок, представляет собой список (возможно, пустой) операторов, заключенных в фигурные скобки ((**)). Синтаксически блок можно рассматривать в качестве единого оператора, но он играет также роль в определении контекста идентификаторов. Идентификатор, объявленный в пределах блока, имеет контекст, начиная с точки объявления и кончая заключающей скобкой. Блоки могут иметь любую глубину вложенности.

Операторы-с-метками

Оператору можно присвоить метку следующим образом:

1. идентификатор-метки : оператор

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

2. case выражение-типа-константы : оператор default : оператор

Операторы с метками case и default используются только в сочетании с операторами выбора.

Операторы-выражения

Любое выражение, за которым следует двоеточие, образует оператор-выражение:

<выражение>

Turbo C++ выполняет операторы-выражения, вычисляя выражения. Все побочные эффекты от этого вычисления завершаются до начала выполнения следующего оператора. Большинство операторов-выражений представляют собой операторы присвоения или вызовы функций.

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

Операторы выбора

Операторы выбора, или операторы управления потоком выполнения программы, выполняют выбор одной из альтернативных ветвей программы, проверяя для этого определенные значения. Сущесвует два типа операторов выбора: if...else и switch.

Операторы if

Базовый оператор if имеет следующий шаблон:

if(условное-выражение) оператор-если-"истина" <else>

оператор-если-"ложь"

Заключение условного-выражения в круглые скобки является важным моментом синтаксиса этого оператора.

Условное-выражение должно быть скалярного типа. Это выражение вычисляется. Если оно является нулевым (или пустым в случае типа указателя), мы говорим, что условное-выражение ложно; в противном случае оно истинно.

Если предложение else отсутствует, а условное-выражение дает значение "истина", то выполняется оператор-если-"истина"; в противном случае он игнорируется.

Если задано опциональное предложениеelse оператор-если-"ложь", а условное-выражение дает значение "истина", то выполняется оператор-если-"истина"; в противном случае выполняется оператор-если"ложь".

Примечание

В отличие от, например, Паскаля, Turbo C++ не имеет специального булевого типа данных. В условных проверках роль такого типа может играть целочисленная переменная или указатель. Выражение отношения (a > b) (если оно допустимо) дает int 1 (истина), если (a > b), и int 0 (ложь), если (a < b). Преобразования указателейвыполняются таким образом, что значение указателя всегда может быть корректно сравнено с выражением типа константы, дающим 0. Таким образом, сравнение для пустых указателей может быть сделано в виде if (lptr)... или if (ptr == 0)....

Оператор-если-"ложь" и оператор-если-"истина" сами могут являться операторами if, что позволяет организовывать любую глубину вложенности условных проверок. При использовании вложенных конструкций if...else следует быть внимательным и обеспечивать правильный выбор выполняемых операторов. Оператор endif здесь отсутствует; любая неоднозначность конструкции "else" разрешается сопоставлением else с последним найденным на уровне данного блока if без else. Например,

if (x == 1)

if (y == 1) puts("x=1 и y=1");

else puts("x != 1");

дает неверное решение! else, независимо от ваших намерений, сопоставляется второму оператору if. Правильное решение это: x=1 и y!=1. Отметим действие фигурных скобок:

if (x == 1)

(*

if (y == 1) puts("x = и y=1");

*)

else puts("x != 1"); // правильное решение

Операторы switch

Оператор switch использует следующий базовый формат:

switch (переключающее-выражение) оператор-варианта

Операторswitchпозволяет передавать управление одному из нескольких операторов с меткой варианта в зависимости от значения переключающего выражения. Последнее должно быть интегрального типа (в С++ оно может быть типа класса, при условии, что возможно его однозначное преобразование к интегральному типу.) Любой оператор в операторе-варианта (включая пустой оператор) может быть помечен одной или более меткой варианта:

case выражение-типа-константы-i : оператор-варианта-i

где каждое выражение-типа-константы-i должно иметь уникальное целочисленное значение (преобразуемое к типу управляющего выражения) в пределах объемлющего оператора switch.

Допускается иметь в одном операторе switch повторяющиеся константы варианта.

Оператор может иметь также не более одной метки default:

default : оператор-умолчания

После вычисления переключающего-выражения выполняется сопоставление результата с одним из выражений-типа-константы -i. Если найдено соответствие, то управление передается оператору-варианта-i с меткой, для которой найдено соответствие.

Если соответствия не найдено и имеется метка default, то управление передается оператору-умолчания. Если соответствия не найдено и метка default отсутствует, то никакие операторы не выполняются. Когда программа встречает метки case и default, это не производит на нее никакого действия. Управление просто передается дальше через метки следующему оператору или переключателю. Для того, чтобы остановить выполнение группы операторов дляконкретного варианта, следует использовать оператор break.

Операторы итерации

Операторы итерации позволяют организовывать циклическое выполнение набора операторов программы. Turbo C++ имеет три формы операторов итерации : циклы while, do и for.

Операторы while

Общий формат данного оператора следующий:

while (условное-выражение) оператор-пока-"истина"

Оператор тела цикла, оператор-пока-"истина", будет циклически повторяться до тех пор, пока вычисление условного выражения не даст значения ноль (ложь).

Условное выражение вычисляется и проверяется первым (как описано на стр.93 оригинала). Если это значение ненулевое (истина), то выполняется оператор-пока-"истина"; если не встречен оператор перехода, выполняющий выход из цикла, то условное-выражение вычисляется снова. цикл повторяется до тех пор, пока условное-выражение не даст значения 0.

Как и в случае оператора if, выражения типа указателя могут сравниваться с пустым указателем, так что while (ptr) ... эквивалентно

while (ptr != NULL)...

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

char str[10]="Borland";

char *ptr=&str[0];

int count=0;

//...

while (*ptr++) // цикл до конца строки

count++;

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

Операторы do while

Общий формат этих операторов следующий:

do выполняемый-оператор while (условное-выражение)

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

Операторы for

Формат оператора for в С следующий:

for(<выражение-инициализации>;<выражение-проверки>; <выражение-инкремента>) оператор

В С++ <выражение-начального-значения> может быть как выражением, так и объявлением.

Последовательность действий при выполнении данного оператора следующая:

1. Выполняется вычисление выражения-инициализации, если таковое задано. Как следует из его названия, это выражение обычно инициализирует один или несколько счетчиков цикла, но его синтаксис в действительности позволяет любую степень сложности (включая в случае С++ объявления). Отсюда следует вывод, что любая программа в С может быть записана в виде единственного цикла for. (Однако не пытайтесь писать в таком стиле без должной подготовки. Такое доступно лишь высоким профессионалам).

2. Выражение-проверки вычисляется по правилам, приводимым для циклов while. Если выражение-проверки ненулевое (истина), то оператор тела цикла выполняется. Пустое выражение трактуется в данном случае как while(1), то есть как если бы условие проверкивыполнялось всегда.Если выражение-проверки дает значение ноль (ложь), то цикл for прекращается.

3. Выражение-инремента выполняет приращения одного или нескольких цикловых счетчиков.

4. Выражение "оператор" (возможно, пустое) вычисляется, после чего управление возвращается на шаг 2.

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

for (;;) (* // то же, что и for(;1;)

// вечный цикл

*)

C++: Правила С для операторов for применимы и в С++. Однако, выражение-инициализации в С++ может также включать в себяи объявление. Контекст объявленного идентификатора продолжается до конца данного оператора, не далее. Напрмер,

for (int i = 1; i < j; ++i)

(*

if (i ...) ...// здесь обращаться к значению i можно *)

if (i ...)// а здесь нельзя : i вне контекста

Операторы перехода

При выполнении оператор перехода происходит безусловная передача управления в некоторую точку программы. Существует четыре таких оператора: break, continue, goto и return.

Операторы break

Синтаксис следующий:

break;

Оператор break можно использовать только внутри операторов итерации (while, doи for - циклы) или с оператором switch. Он прекращает выполнение итерации или оператора switch. Поскольку операторы итерации и оператор switch могут комбинироваться и иметь любуюглубину вложенности, следует обращать особое внимание на то, чтобы оператр break выполнял выход именно из нужного цикла или оператора switch. Правило состоит в том, что оператор break заканчивает выполнение ближайшего к нему объемлющего цикла итерации или оператора switch.

Операторы continue

Синтаксис следующий:

continue;

Оператор continue может быть использован только внутри оператора итерации; он передает управление на проверку условия циклов while и do, либо на выражение инкремента цикла for.

При вложенностициклов итерации оператор continue считается принадлежащим ближайшей объемлющей итерации.

Операторы goto

Синтаксис следующий:

goto метка;

Оператор goto передает управление оператору, имеющему указанную "метку" (См. "Операторы с метками" на стр.92 оригинала), который должна находиться в пределах той же функции.

С++: В С++ допустимо обойти объявление с явным или неявным инициализатором, если это объявление не находится во внутреннем блоке, который также обходится.

Операторы return

Если тип возврата функции не равен void, то тело функции должно содержать как минимум один оператор return следующего формата:

return выражение-возврата;

где выражение-возвратадолжно быть типа type или типа, преобразуемого к типу, заданному type, при присвоении. Значение выражениявозврата и есть значение, возвращаемое данной функцией. Выражение, вызывающее функцию, вида func(список-действительных-аргументов) является значением rvalue типа type, а не именующим (lvalue) значением.

t = func(arg); // так можно

func(arg) = t; /* в С так нельзя; в С++ так можно, если типом возврата func является ссылка */

(func(arg))++; /* в С так нельзя; в С++ так можно,если типом возврата func является ссылка */

Выполнение вызова функции заканчивается, когда встретился оператор return; если оператор return отсутствует, то выполнение "проваливается" к последней закрыващей фигурной скобке тела функции.

Если тип возврата void, то оператор return можно записать как:

(*

...

return;

*)

без выражения-возврата, либо оператор return вообще может быть опущен.

С++

В целом, С++ является над-множеством языка С. Это означает, что, вообще говоря, можно компилировать программы С в среде С++, однако компилировать программы С++ в среде С при наличии в них каких-либо специфических для С++ конструкций нельзя. Некоторые ситуации требуют специального внимания. Одна и та же функция func, дважды объявленная в С с различными значениями аргументов, вызовет ошибку повторения имен. Однако, в С++ func интерпретируется как перегруженная функция - а то, допустимо это или нет,зависит от других обстоятельств. Общие вопросы программирования на С++ см. в главе 5, "Основы С++" документа "Начало работы". Глава 6, "Краткий справочник по С++" в том же документе поможет вам быстро понять, как именно работают конструкции языка.

Хотя С++ вводит новые ключевые слова и операции для работы с классами, некоторые средства С++ применимы вне контекста классов. Сначала мы рассмотрим тиенно эти, используемые незвисимо от классов средства, а затем займемся спецификой работы с классами и связанными с ними механизмами.

Ссылки

Установка ссылок при помощи указателей и обращение по ссылкам рассматриваются на стр.80 оригинала.

Типы ссылок Turbo C++ тесно связаны с типами указателей. Типы ссылок С++ служат для создания алиасов объектов и позволяют передачу аргументов функциям по ссылке. Традиционно С передает аргументы только по значению. С++ позводяет передавать аргументыкак по значению, так и по ссылке.

Простые ссылки

Для объявления ссылок вне функции может быть использован декларатор ссылки:

int i = 0;

int &ir = i; // ir является алиасом i

ir = 2; // то же, что i = 2

В данном примере создается именующее значение ir, являющееся алиасом i, при условии, что инициализатор имеет тот же тип, что и ссылка. Выполнение операций с ir имеет тот же результат, что и выполнение их с i. Напрмер, ir = 2 присваивает 2 переменной i, а &ir возвращает адрес i.

Аргументы типа ссылки

Декларатор ссылки может также быть использован для объявления в функции параметров типа ссылки:

void func1 (int i);

void func2 (int &ir); // ir имеет тип "ссылка на int"

...

int sum=3;

func1(sum); // sum передается по значению func2(sum) // sum передается по ссылке

Переданный по ссылке аргумент sum может быть изменен прямо в func2. Напротив, func1 получает только копию аргумента sum (переданного по значению), поэтому сама переменная sum функцией func1 изменена быть не может.

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

Традиционный метод С для изменения x состоит в использовании в качестве фактического аргумента &x, то есть адреса x, а не самого значения x. Хотя &x передается по значению, функция получает доступ к x благодаря тому, что ей доступна полученная копия&x. Даже если функции не требуется изменять значения x, тем не менее полезно (хотя это чревато возможностью нежелательных побочныхэффектов) передавать &x, особенно если x представляет собой большую по размерам структуру данных. Передача x непосредственно по значению ведет к бесполезным затратам памяти на копирование такой структуры данных.

Сравним три различных реализации функции treble:

Реализация 1

int treble_1(n)

(*

return 3*n;

*)

...

int x, i = 4;

x = treble_1(i); // теперь x = 12, i = 4

...

Реализация 2

void treble_2(int* np)

(*

*np = (*np)*3;

*)

...

treble_2(int &i); // теперь i = 12

Реализация 3

void treble_3(int& n) // n имеет тип ссылки

(*

n = 3*n;

*)

...

treble_3(i); // теперь i = 36

Объявление формального аргумента type& t (или, что эквивалентно, type &t) устанавливает t как имеющую тип "ссылки на тип type". Поэтому при вызове treble_3 с действительным аргументом i, i используется для инициализации формального аргумента ссылки n. Следовательно, n играет роль алиаса i, и n = 3*n также присваивает i значение 3*i.

Если инициализатор представляет собой константуили объект нессылочного типа, то Turbo C++ создаст временный объект, для которого ссылка действует как алиас:

int& ir = 6; /* создается временный объект int, с именем алиаса ir, который получает значение 6 */

float f;

int& ir2 = f; /* создается временный объект int, с именем алиаса ir2, f перед присвоением преобразовывается */

ir2 = 2.0 // теперь ir2 = 2, но f остается без изменений

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

Операция доступа к контексту

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

int i; // глобальная переменная i

...

void func(void);

(*

int i=0; // локальная i скрывает глобальную i i = 3; //

эта i - локальная

::i = 4; // эта i - глобальная

printf ("%d",i); // будет напечатано значение 3

*)

Приведенный кодработает также, если i является статической переменной уровня файла.

При использовании с типами классов операция :: имеет другой смысл; это рассматривается далее в данной главе.

Операции new и delete

Операцииnew и delete выполняют динамическое распределение и отмену распределения памяти, аналогично, но с более высоким приоритетом, нежели стандартныке библиотечные функции семейства malloc и free (См. справочник по библиотеке).

Упрощенный синтаксис:

указатель-имени = new имя <инициализатор-имени>;

delete указатель-имени;

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

new пытается создать объект с типом "имени", распределив (при возможности) sizeof(имя) байт в свободной области памяти (которую также называют "кучей"). Продолжительность существования в памяти данного объекта - от точки его создания и до тех пор, пока операция delete не отменит распределенную для него память, либо до конца работы программы.

В случае успешного завершения new возвращает указатель нового объекта. Пустой указатель означает неудачное завершение операции (например, недостаточный объем или слишком большая фрагментированность кучи). Как и в случае malloc, прежде чем пытаться обращаться к новому объекту, следует проверить укеазатель на наличие пустого значения. Однако, в отличие от malloc, new сама вычисляет размер "имени", и явно указывать операцию sizeof нет необходимости. Далее возвращаемый указатель будет иметь правильный тип, "указатель имени", без необходимости явного приведения типов.

name *nameptr // name может иметь любой тип, кроме функции

...

if (!(nameptr = new name)) (*

errmsg("Недостаточно памяти для name");

exit (1);

*)

// использование *nameptr для инициализации объекта new name

...

delete nameptr; // удаление name и отмена распределения

// sizeof(name) байтов памяти

new, будучи ключевым словом, не нуждается в прототипе.

Операция new с массивами

Если "имя" это массив, то возвращаемый new указатель указывает на первый элемент массива. При создании с помощью new многомерных массивов следует указывать все размерности массива:

mat_ptr = new int[3][10][12]; // так можно

mat_ptr = new int[3][][12]; // нельзя

mat_ptr = new int[][10][12]; // нельзя

::operator new

При использовании с объектами, не являющимися классами, new вызывает стандартную библиотечную подпрограмму, global ::operator new. Для объектов классов типа "имя" может быть определена специальная операция имя::operator new. new, применительнок объектам класса "имя", запускает соответствующую операцию имя::operator new; в противном случае используется стандартная операция ::operator new.

Инициализаторы с операцией new

Другим преимуществом операции new по сравнению с malloc является опциональный инициализатор (хотя calloc очищает его распределение к нулю). При отсутствии явных инициализаторов объект, создаваемый new, содержит непредсказуемые данные ("мусор"). Объекты, распределяемые new, за исключением массивов, могут инициализироваться соответствующим выражением в круглых скобках:

int_ptr = new int(3);

Массивы классов с конструкторами инициализируются при помощи конструктора-умолчания (см. стр.115 оригинала). Определяемая пользователем операция new с задаваемой пользователем инициализацией играет ключевую роль в конструкторах С++ для объектов типа класса.

Классы

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

В С++ структуры и объединения рассматриваются как классы с определенными умолчаниями правил доступа.

Упрощенный, в "первом приближении", синтаксис объявления класса следующий:

ключ-класса имя-класса

<:базовый-список>[<список-компонентов>]

Ключ-класса - это class, struct или union.

Опциональный базовый-список перечисляетбазовый классили классы, из которогоимя-класса берет (или наследует) объекты и правила. Если объявлены некоторые базовыеклассы, то класс "имя-класса" называется производным классом (см.стр.110, "Доступ к базовым и производным классам"). Базовый список содержит спецификаторы доступа по умолчания и опциональные их переопределения, которые могут модифицировать права доступа производного класса к компонентам базовых классов(см. стр.108 оригинала, "Управление доступом к компонентам").

Опциональный список-компонентов объявляет компоненты класса (данные и функции) для имени-класса с умолчаниями и переопределениями спецификаторов доступа, которые могут влиять на то, какие функции к каким компонентам класса могут иметь доступ.

Имена классов

Имя-класса это любой идентификатор, уникальный в пределах своего контекста. В классах структур и в объединениях имя-класса можетбыть опущено (см. "Структуры и типы, определяемые пользователем (typedef) без тегов" на стр.65 оригинала).

Типы классов

Объявление создает уникальный тип, тип класса

"имя-класса". Это позволяет вам объявлять последующие объекты класса (или вхождения класса) данного типа, а также объекты, являющиеся производными от этого типа (такие как указатели, ссылки, массивы объектов "имя-класса" и т.д.):

class X (* ... *);

X x, &xr, *xptr, xarray[10];

/* четыре объекта: типа X, ссылка на X, указатель на X и масив элементов типа X */

struct Y (* ... *);

Y y, &yr, *yptr, yarray[10];

// С позволяет иметь

// struct Y y, &yr, *yptr, yarray[10];

union Z (* ... *);

Z z, &zr, *zptr, zarray[10];

// С позволяет иметь

// union Z z, &zr, *zptr, zarray[10];

Отметим различие между объявлением структур и объединений в С и С++: в С ключевые слова struct и union обязательны, но в С++ они нужны только в том случае, когда имена классов, Y и Z, скрыты (см. следующий раздел).

Контекст имени класса

Контекст имени класса является локальным, с некоторыми особенностями, характерными для классов. Контекст имени класса начинается с точки его объявления и заканчивается вместе с объемлющим блоком. Имя класса скрывает любой класс, объект, нумератор или функцию с тем же именем в объемлющем контексте. Еслиимя класса объявлено в контексте, содержащем объявление объекта, функции или нумератора с тем же именем, обращение к классу возможно только при помощи уточненного спецификатора типа. Это означает, что с именем класса нужноиспользовать ключ класса, class, struct или union. Например,

struct S (* ... *);

int S(struct S *Sptr);

void func(void)

(*

S t; // недопустимое объявление: нет ключа класса // и функции S в контексте struct S s; // так можно: есть уточнение ключем класса

S(&s); // так можно: это вызов функции

*)

С++ позволяет также неполное объявление класса:

class X;// еще нет компонентов !

struct Y;

union Z;

Неполные объявления позволяют некоторые ссылки к именам классов X, Y или Z (обычно ссылки на указатели объектов классов) до того, как классы будут полностью определены (см. "Объявление компонентов структуры" на стр.65 оригинала). Разумеется, прежде чем вы сможете объявить и использовать объекты классов, вы должны выполнить полное объявление классов со всеми их компонентами.

Объекты классов

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

Список компонентов класса

Опциональный список-компонентов представляет собой последовательность объявлений данных (любого типа, включая нумераторы,битовыеполя и другие классы) и объявлений и определений функций, каждое из которых может иметьопциональные спецификаторы класса памяти и модификаторы доступа. Определенные таким образом объекты называются компонентами класса. Спецификаторы класса памяти auto, extern и register в данном случвае недопустимы. Компоненты могут быть объявлены со спецификаторами класса памяти static.

Функции-компоненты

Функция, объявленная без спецификатораfriend, называется функцией-компонентом класса. Функции, объявленные с модификатором friend, называется "функцией-другом".

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

Ключевое слово this

Не-статические функции компонентов работают с объектами типа класса, с которыми они вызываются. Например, если xэто объект класса X, а f это функция-компонент X, то вызов функци x.f() работает с x. Аналогичным образом, если xptr есть указатель объекта X, то вызов функции xptr->() работает с *xptr. Откуда f может знать, с каким x работать? С++ передает f указатель на x, называемый this. this передается как скрытый аргумент при вызове не-статических функций-компонентов.

Ключевоеслово this представляет собой локальную переменную, доступную в теле не-статической функции-компонента. this не требует объявлений, и на него редко встречаются явные ссылки в определении функции. Однако, оно неявно используется в функции для ссылки ккомпонентам. Если, например, вызывается x.f(y), где y есть компонент X, то this устанавливается на &x, а y устанавливается на this->y, что эквивалентно x.y.

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

Функция-компонента может быть объявленав пределах своего класса, но определена где-либо в другом месте. И наоборот, функция-компонента может быть и объявлена, и определена в своем классе, и тогда она называется встраиваемой функцией. (Некоторые примеры таких функций показаны в главе 5 документа "Начало работы").

В некоторых случаях Turbo C++ может уменьшить затраты времени на вызов функции, подстанавливая вместо вызова функции непосредственно компилированный код тела функции. Этот процесс, называемый встраиваемым расширением тела функции, не влияет на контекст имени функции или ее аргументов. Встраиваемое расширение не всегда полезно и желательно. Спецификатор inline представляет собой запрос (или требование) компилятору, в котором вы сообщаете, что встраиваемые расширения желательны. Как и в случае спецификатора класса памяти register, компилятор может либо удовлетворить, либо проигнорировать ваше пожелание.

Явные или неявные запросы inlineлучше всего резервировать для небольших по объему и часто вызываемых функций, таких как функции типа operator, реализующих перегруженные операторы. Например, следующее объявление класса:

int i; // global int

class X (*

public:

char* func(void) (* return i; *) // inline по умолчанию char* i;

*);

эквивалентно

inline char* X::func(void) (*return i; *)

func определяется "вне" класса с явным спецификатором inline. Переменная i, возвращаемая func, есть char* i класса X - см. раздел, посвященный контексту компонентов на стр.107 оригинала.

Статические компоненты

Спецификатор класса памяти static может быть использован в объявлениях компонентов данных и функций-компонентов класса. Такие компоненты называются статическими и имеют свойства, отличные от свойств не-статических компонентов.В случае не-статических компонентов для каждого объекта класса "существует" отдельная копия; в случае же статических компонентов существует только одна копия, а доступ к ней выполняется без ссылки на какой-либо конкретный объект класса. Если х это статический компонент класса Х, то к нему можно обратиться как Х::х (даже если объекты класса Х еще не созданы). Однако, можно выполнить доступ к х и при помощи обычных операций доступа к компонентам. Например, в виде y.x и yptr->x, гдеy это объект класса X, а yptr это указатель объекта класса X, хотя выражения y и yptr еще не вычислены. В частности, статическая функция-компонент может быть вызвана как с использованием специального синтаксиса вызова функций компонентов, так и без него.

class X (*

int member_int;

public:

static void func(int i, X* ptr);

*);

void g(void);

(*

X obj;

func(1, &obj); // ошибка, если где-нибудь еще

// не определена глобальная func()

X::func(1, &obj); // вызов static func() в X // допустим только для статических функций

obj.func(1, &obj); // то же самое (допустимо как для стати// ческих, так и не-статических функций)

*)

Поскольку статическая функция-компонент может вызываться без учета какого-либо конкретногообъекта, она не имеет указателя this. Следствие из этого таково, что статическая функция-компонент не имеет доступа к не-статическим компонентам без явного задания объекта при помощи .или ->. Например, сучетомобъявлений, сделанных впредыдущем примере, func может быть определена следующим образом:

void X%%func(int i, X* ptr)

(*

member_int = i; // на какой объект ссылается

// member_int? Ошибка !

ptr->member_int = 1; // так можно: теперь мы знаем! *)

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

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

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

class X (*

...

static int x;

...

*); int X::x = 1;

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

- уменьшения числа видимых глобальных имен

- того, чтобы сделать очевидным, какие именно статические объекты какому классу принадлежат

- разрешения управления доступам к их именам.

Контекст компонента

Выражение X::func() в примере, приведенномна стр.106 оригинала, используетимя класса Xс модификатором контекста доступа, обозначающим, что func, хотя и определена "вне" класса, в действительности является функцией-компонентом Х и существует в контексте Х. Влияние Х:: распространяется на тело определения этой функции. Это объясняет, почему возвращаемое функциейзначение i относится к X::i, char* i из Х, а не к глобальной переменной int i. Без модификатора Х:: функция func представляла бы обычную, не относящуюся к классу функцию, возвращающую глобальную переменную int i.

Следовательно, все функции-компоненты находятся в контексте своего класса, даже если они определены вне этого класса.

К компонентам данных класса Х можно обращаться при помощи операций выбора . и -> (как и в структурах С). Функциикомпоненты можновызывать также при помощи операций выбора (см. "Ключевое слово this на стр.105 оригинала). Например,

class X (*

public:

int i;

char name[20];

X *ptr1;

X *ptr2;

void Xfunc(char *data, X* left, X* right); // определение // находится не здесь

*);

void f(void);

(*

X x1, x2, *xptr=&x1; x1.i = 0; x2.i = x1.i; xptr->i = 1; x1.Xfunc("stan", &x2, xptr);

*)

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

Компоненты класса не могут быть добавлены к нему в другом разделе вашейпрограммы. Класс Х не может содержать объекты класса Х, но может содержать указатели или ссылки на объекты класса Х (отметим аналогию с типами структур и объединений С).

Управление доступом к компонентам

Компоненты класса получают атрибуты доступа либо по умолчанию (взависимости от ключакласса и местоположения объявления), либо при использовании какого-либо из спецификаторов доступа: public, private или protected. Значение этих атрибутов следующие:

public Компонент может быть использован любой функцией.

private Компонент может быть использован только функциями компонентами и "друзьями" класса, в котором он объявлен.

protected То же самое, что для private, но кроме того, компонент может быть использован функциями компонентов идрузьями классов, производных от объявленного класса,но только в объектах производного типа. (Производные классы рассматриваются в следующем разделе).

Спецификаторы доступа не влияют на объявления функций типа friend. (См. раздел "Друзья" классов" на стр.112 оригинала).

Компоненты класса по умолчанию имеют атрибут private, поэтому для переопределенияданного объявления спецификаторы доступа public или protected должны задаваться явно.

Компоненты struct по умолчанию имеют атрибут public, но вы можете переопределитьэто умолчаниепри помощи спецификаторов доступа public или protected.

Компоненты union поумолчанию имеют атрибут public; переопределить его нельзя. Все три спецификатора доступа задавать для компонентов объединения недопустимо.

Модификатор доступа по умолчанию или заданный для переопределения атрибута доступа остается действительным для всех последующих объявлений компонентов, пока не встретится другой модификатор доступа. Например,

class X (*

int i; // X::i по умолчанию privte

char ch; // так же, как и X::ch

public:

int j; // следующие два компонента - public

int k;

protected:

int l; // X::l - protected

*);

struct Y (*

int i; // Y::i по умолчанию public

private:

int j; // Y::j - private

public:

int k; // Y::k - public

*);

union Z (*

int i; // public по умолчанию, других вариантов нет

double d;

*);

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

Доступ к базовым и производным классам

При объявлении производного класса D вы перечисляете базовые классы В1, В2 ... в разделяемом запятой базовом-списке:

ключ-класса D:базовый-список (*<список-компонентов>*)

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

D наследует всем компонентамбазовых классов. (Переопределенные компоненты базовых классов наследуются, ипри необходимостидоступк нимвозможен при помощи переопределений контекста). D может использовать только компоненты базовых классов с атрибутами public и protected. Однако, что будут представлять собойатрибуты доступа унаследованных компонентов с точки зрения D? D может понадобиться использоватьpublicкомпонент базового класса, но при этом сделать его для внешних функций private. Решение здесь состоитв том, чтобыиспользовать спецификаторы доступа в базовом-списке.

При объявлении D вы можете задать спецификатор доступа public или private перед классами в базовом-списке:

class D : public B1, private B2, ... (*

...

*)

Задать в базовом-списке protected нельзя. Объединения не могут содержать базовых классов и не могут сами быть использованы в качестве базовых классов.

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

Умолчанием является private, если D есть объявление класса class, и public, если D есть объявление структуры struct.

Производный класс наследует атрибуты доступа базового класса следующим образом:

базовый класс public: компоненты public базового классастановятся членами public производного класса. Компоненты pro- tected базового класса становятся компонентами protected производногокласса. Компоненты private базового класса остаютсядля базового класса private.

базовый класс private: и public, и protected компоненты базового классастановятся private компонентами производного класса.Компоненты private базового класса остаются для базового класса private.

В обоих случаях отметим, что компоненты private базового класса былии остаются недоступными дляфункций-компонентов производного класса, пока в описании доступа базового класса не будут явно заданы объявления friend. Например,

class X : A (* // умолчание для класса - private A

...

*)

/* класс X является производным от класса А */

class Y : B, public C (* // переопределяет умолчание для С

...

*)

/* класс Y является производным (множественное наследование) от B и C. По умолчанию - private B */

struct S : D (* // умолчание для struct - public D

... /* struct S - производная от D */

*)

struct T : private D, E (* // переопределяет умолчание для D // E по умолчанию public

...

*)

/* struct T является производной (множественное наследование) от D и T. По умолчанию - public E */

Действие спецификаторов доступа в базовом списке можно скорректировать при помощи квалифицированного-имени вобъявлениях public или protected для производного класса. Например,

class B (*

int a; // по умолчанию private

public:

int b, c;

int Bfunc(void);

*);

class X : private B (* // теперь в Х a, b, c и Bfunc - private int d; // по умолчанию private. Примечание: f

// в Х недоступна

public:

B::c; // c была private; теперь она public

int e;

int Xfunc(void);

*);

int Efunc(X& x); // внешняя по отношению к В и Х

Функция Tfunc может использовать только имена с атрибутом public, например c, e и Xfunc.

Функция Xfunc в X является производной от private B, поэтому она имеет доступ к:

- "скорректированной-к-типу-public" c

- "private-относительно-Х" компонентам В:b и Bfunc

- собственным private и public компонентам: d, e и Xfunc.

Однако, Xfunc не имеет доступа к "private-относительно- B" компоненту a.

Виртуальные базовые классы

При множественном наследованиибазовый класс не может быть задан в производном классе более одного раза:

class B (* ... *);

class D : B, B (* ... *): // недопустимо

Однако, базовый класс может быть передан производному классу более одного раза косвенно:

class X : public B (* ... *)

class Y : public B (* ... *)

class Z : public X, public Y (* ... *) // допустимо

В данном случае каждый объект класса Z будет иметь два подобъекта класса В. Если это вызывает проблемы, к спецификатору базового класса может бытьдобавлено ключевое слово virtual. Например,

class X : virtual public B (* ... *)

class Y : virtual public B (* ... *)

class Z : public X, public Y (* ... *)

Теперь В является виртуальным базовым классом,а класс Z имеет только один под-объект класса В.

"Друзья" классов (friend)

Друг F класса X это функция или класс, которые, не являясь функцией-компонентом Х, имеют тем не менее полные права доступа к компонентам Х private и protected. Во всех прочих отношениях F это обычная с точки зрения контекста, объявлений иопределений функция.

Поскольку F не является компонентом Х, она не лежит в контексте Х и поэтому не может вызываться операциями выбора x.F и xptr->F (где x это объект Х, а xptr это указатель объекта Х.

Если в объявлении или определении функции в пределах класса Х используется спецификатор friend, то такаяфункция становится "другом" класса Х.

Функция-"друг", определенная в пределах класса, подчиняется тем же правилам встраивания, что и функции-компоненты класса (см. "Встраиваемые функции" на стр.105 оригинала). Функции-"друзья" не зависят от их позиции в классе или спецификаторов доступа. Например,

class X (*

int i; // private относительно Х

friend void friend_func(X*, int);

/* friend_func не является private, хотя она и объявлена

в разделе private */

public:

void member_func(int);

*);

/*объявления;для обеих функций отметим доступ к private int i*/

void friend_func(X* xptr, int a) (* xptr->i = a; *)

void X::member_func(int a) (* i = a; *)

X xobj;

/* отметим различие в вызовах функций */

friend_func(&xobj, 6);

xobj.member_func(6);

Вы можете сделать все функции класса Y друзьями класса Х в одном объявлении:

class Y; // неполное объявление

class X (*

friend Y;

int i;

void member_funcX();

*);

class Y; (*

void friend_X1(X&);

void friend_X2(X*);

...

*);

Функции, объявленные в Y, являются друзьями Х, хотя они и не имеютспецификаторовfriend. Они имеют доступ к компонентам Х private, таким как i и member_funcX.

Отдельные функции-компоненты класса Хтакже могут быть друзьями класса Y:

class X (*

...

void member_funcX();

*)

class Y (*

int i;

friend void X::member_funcX();

...

*);

"Дружба" классов не транзитивна: если X друг Y, а Y друг Z, это не означает, что X - друг Z. Однако, "дружба" наследуется. Конструкторы и деструкторы

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

1. Они не имеют объявлений значений возврата (даже void).

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

3. Конструкторы, как и большинство функций С++, могут иметь аргументы по умолчанию или использовать списки инициализации компонентов.

4. Деструкторы могут иметь атрибут virtual, но конструкторы не могут.

5. Вы не можете работать с их адресами:

main()

(*

...

void *ptr = base::base; // недопустимо

...

*)

6. Если конструкторы и деструкторы не были заданы явно, то они могут быть сгенерированы Turbo C++; во многих случаях они также могут быть запущены при отсутствии явного вызова в вашей программе. Любой конструктор или деструктор, создаваемый компилятором, должен иметь атрибут public.

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

8.

(*

...

X *p;

...

p->X::-X();// допустимый вызов деструктора

X::X();// недопустимый вызов конструктора

...

*)

9. При определении и разрушении объектов компилятор выполняет вызов конструкторов и деструкторов автоматически.

10.Конструкторы и деструкторы при необходимости распределения объекту памяти могут выполнять неявные вызовы операций new и delete.

11.Объект с конструктором или деструктором не может быть использован в качестве компонента объединения.

Если класс Х имеет один или более конструкторов, то один из них запускается всякий разпри определении объекта х класса Х. Конструктор создает объект х и инициализирует его. Деструкторы выполняют обратный процесс,разрушая объекты класса, созданные конструкторами.

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

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

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

Локальные объекты создаются, как только становится активным контекст переменной.Конструктор также запускается при создании временного объекта данного класса.

class x

(*

public:

X(); //конструктор класса Х

*);

Конструктор класса Х не может принимать Х как аргумент:

class X (*

...

public

X(X); // недопустимо *)

Параметры конструкторы могут быть любого типа, за исключением класса, компонентомкоторого является данный конструктор. Конструктор может приниматьв качестве параметра ссылку на свой собственный класс; в таком случае он называется конструктором копирования.Конструктор, не принимающийпараметров вообще, называется конструктором поумолчанию. Далее мы рассмотрим конструкторы по умолчанию; описание же конструктора копирования начинается со стр.116 оригинала.

Конструктор по умолчанию

Конструктором по умолчанию для класса Х называется такой конструктор, который не принимает никаких аргументов: Х::Х(). Если длякласса несуществует конструкторов, определяемых пользователем, то Turbo C++ генерирует конструктор по умолчанию. При таких объявлениях, как Х х, конструктор по умолчанию создает объект х.

Важное примечание:

Как и все функции, конструкторымогут иметь аргументы по умолчанию. Например, конструктор

X::X(int, int = 0)

можетпринимать один или два аргумента. Если данный конструктор будет представлен только с одним аргументом,недостающий второй аргумент будет принят как int 0. Аналогичным образом, конструктор

X::X(int = 5, int = 6)

может принимать двааргумента, один аргумент, либо не принимать аргументов вообще,причем в каждом случаепринимаются соответствующие умолчания. Однако, конструктор по умолчанию Х::Х() не принимаетаргументов вообще, иего не следует путать с конструктором, например, X::X(int = 0), который может либо принимать один аргумент, либо не принимать аргументов.

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

class X

(*

public:

X();

X(int i = 0);

*);

main()

(*

X one(10); // так можно: используется X::X(int)

X two; // так нельзя; неоднозначно задано, используется // ли X::X() или X::X(int = 0)

...

return 0;

Конструктор копирования

Конструктор копированиядля класса Х это такой конструктор, который может быть вызван с одним единственным аргументом типа X: X::X(const X&) или X::(const X&, int = 0). В конструкторе копирования допустимыми такжеявляются аргументы по умолчанию. Конструкторыкопирования запускаются при копировании объекта данного класса, обычно в случае объявления с инициализацией объектом другого класса: X x = y. Turbo C++ генерирует конструктор копирования для класса X автоматически, если такой конструктор необходим, но в классе Х неопределен.

Перегрузка конструкторов

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

class X

(*

int integer_part;

double double_part;

public:

X(int i) (* integer_part = i; *)

X(double d) (* double_part = d *)

*);

main()

(*

X one(10); // запускает X::X(int) и устанавливает // integer_part в значение 10

X one(3.14); // запускает X::X(double) ш устанавливает // double_part

...

return 0;

*)

Порядок вызова конструкторов

В случае, когда класс использует одинили более базовых классов, конструкторы базовых классов запускаются до того, как будутвызваны конструкторы производного класса. Конструкторы базового класса вызываются в последовательности их объявления.

Например, в следующем примере

class Y (*...*)

class X : public Y (*...*)

X one;

вызов конструкторов происходит в следующей последовательности:

Y(); // конструктор базового класса

X(); // конструктор производного класса

В случае множественных базовых классов:

class X : public Y, public Z

X one;

конструкторы вызываются в последовательности их объявления:

Y(); // первыми следуют конструкторы базового класса Z();

X();

Конструкторы виртуальных базовых классов запускаются до каких-либо не-виртуальных базовых классов. Если иерархия содержит множественные виртуальные базовые классы, то конструкторы виртуальных базовых классов запускаются в последовательности их объявления. Затем,перед вызовомконструкторов производного класса, конструируются не-виртуальные базовые классы.

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

class X : public Y, virtual public Z

X one;

определяет следующую последовательность:

Z(); // инициализация виртуального базового класса Y(); // не-виртуальный базовый класс

X(); // произвольный класс

Либо, в более сложном случае,

class base;

class base2;

class level1 : public base2, virtual public base; class level2 : public base2, virtual public base; class toplevel : public level1, virtual public level1; toplevel view;

Порядок конструирования view будет принят следующий:

base(); // старший в иерархии виртуальный базовый класс // конструируется только однажды

base2(); // не-виртуальная база виртуальной базы level2 // вызывается для конструирования level2

level2(); // виртуальный базовый класс

base2(); // не-виртуальная база для level1

level1(); // другая не-виртуальная база

toplevel();

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

Конструкторы элементовмассива запускаютсяв порядке возрастания индексов массива.

Инициализация класса

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

Объекты классов с конструкторами могут быть инициализированы при помощи задаваемых в круглых скобках списков инициализаторов. Этот список используется как список передаваемых конструктору аргументов. Альтернативнымспособом инициализации является использованиезнака равенства, за которымследует отдельное значение. Это отдельное значение можетиметь тип первого аргумента, принимаемого конструктором данного класса; в этом случае дополнительных аргументов либо не существует, либо они имеютзначения по умолчанию. Значение может также являться объектом данного типа класса. В первом случае для создания объекта вызывается соответствующийконструктор. В последнем случае вызывается конструктор копирования, инициализирующий данный объект.

class X

(*

int i;

public:

X(); // тела функций для ясности опущены

X(int x);

X(const X&);

*);

main()

(*

X one; // запуск конструктора по умолчанию

X two(1); // используется конструктор X::X(int)

X three = 1; // вызывает X::X(int)

X four = one; // запускает X::X(const X&) для копирования X five(two); // вызывает X::X(cont X&)

Конструктор может присваивать значения своимкомпонентам следующим образом. Он может принимать значения в качестве параметров и выполнять присваивание компонентам переменным собственно в теле функции конструктора:

class X

(*

int a, b;

public:

X(int i, int j) (* a = i; b = j *)

*);

Либо он может использовать находящийся до тела функции список инициализаторов:

class X

(*

int a, b;

public:

X(int i, int j) : a(i), b(j) (**)

*);

В обоих случаях инициализация X x(1, 2) присваивает значение 1 x::a и значение 2 x::b. Второй способ, а именно список инициализаторов, обеспечивает механизм передачи значений конструкторам базового класса.

Конструкторы базовогокласса должны быть объявлены с атрибутами public или protected, для того, чтобыобеспечить возможность их вызова из производного класса.

class base1

(*

int x;

public:

base1(int i) (* x = i; *)

*);

class base2

(*

int x;

public:

base2(int i) : x(i) (**)

*);

class top : public base1, public base2

(*

int a, b;

public:

top(int i, int j) : base(i*5), base2(j+i), a(i) (* b = j;*)

*);

В случае такойиерархии класса объявление top one(1, 2) приведет к инициализации base1 значением 5, а base2 значением 3. Методы инициализации могут комбинироваться друг с другом.

Как было описано выше, базовые классы инициализируются в последовательности объявления.Затем происходит инициализация компонентов, также в последовательности их объявления, независимо от их взаимного расположения в списке инициализации.

class X

(*

int a, b;

public:

X(int i, j) : a(i), b(a+j) (**)

*);

В пределах класса объявление X x(1,1) приведет к присваиванию числа 1 x::a и числа 2 x::b.

Конструкторы базовых классов вызываются перед конструированием любых компонентов производных классов. Значения производного класса не могут изменяться и затем влиять на создание базового класса.

class base

(*

int x;

public:

base(int i) : x(i) (**)

*);

class derived : base

(*

int a;

public:

derived(int i) : a(i*10), base(a) (**) // Обратите внимание! // base будет передано неинициализированное a

*)

В данномпримере вызовпроизводного d(1) неприведет к присвоению компоненту базового класса х значения 10. Значение, переданное конструктору базового класса, будет неопределенным.

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

derived::derived(int i) : a(i)

(*

...

*)

Деструкторы

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

class X

(*

public:

-X(); // деструктор класса X

*);

Если деструкторне объявлен для класса явно, компилятор генерирует его автоматически.

Запуск деструкторов

Вызов деструктора выполняется неявно, когда переменная выходит из своего объявленного контекста. Для локальных переменных деструкторы вызываются, когда перестает быть активным блок, в котором они объявлены. В случае глобальных переменныхдеструкторы вызываются как часть процедуры выхода после main.

Когда указатели объектов выходят запределы контекста, неявный вызов деструктора непроисходит. Это значит, чтодля разрушения такого объекта операция delete должна быть задана явно.

Деструкторы вызываются строго в обратной последовательности относительнопоследовательности вызова соответствующих им конструкторов (см. стр.117 оригинала).

atexit, #pragma exit и деструкторы

Все глобальные объекты остаются активными до тех пор, пока не будут выполнены коды во всех процедурах выхода. Локальные переменные, включая те, что объявлены в main, разрушаютсяпри выходе их из контекста. Последовательность выполнения в конце программы Turbo C++ в этом смысле следующая:

- выполняются функции atexit в последовательности их вставки в программу

- выполняются функции #pragma exit в соответствии с кодами их приоритетов

- вызываются деструкторы глобальных переменных.

exit и деструкторы

При вызове exitиз программы деструкторы для каких-либо локальных переменных в текущем контексте не вызываются. Глобальные переменные разрушаются в обычной последовательности.

abort и деструкторы

При вызове abort где-либо из программы деструкторы не вызываются, даже для переменных глобального контекста.

Деструктор можетбыть также вызван явно, одним из двух следующих способов: косвенно, через вызовdelete, или прямо, задавая полностью квалифицированногоимени деструктора. Delete можноиспользовать для разрушения объектов, для которых память распределялась при помощи new. Явный вызов деструктора необходим только в случае объектов, которым распределялся конкретный адрес памяти при помощи new.

class X (*

...

-X();

...

*);

void* operator new(size_t size, void *ptr)

(*

return ptr;

*)

char buffer[sizeof(x)];

main()

(*

X* pointer = new X;

X* exact_pointer;

exect_pointer = new(&buffer) X;// указатель

инициализиру// ется адресом буфера

...

delete pointer;// delete служит для раз-

// рушения указателя

exact_pointer->X::-X();// прямой вызов для отмены

// распределения памяти

*)

Виртуальные деструкторы

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

Внимание: пример проограммы см в файле prog_1.app

Однако, если ни один из деструкторов не был объявлен виртуальным,delete palette[0], delete palette[1] и delete palette[2] вызывают только деструктор дляклассаcolor.Это приведет к неправильному разрушению первых двух элементов, которые фактически имели тип red и brightred.

Перегруженные операции

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

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

..* :: ?:

Также невозможна перегрузка символов препроцессора # и ##.

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

Операция-функция, вызываемая саргументами, ведет себя как операция, выполняющая определенные действия с операндами в выражении. Операция-функция изменяет число аргументов или правила приоритета и ассоциативности операции (таблица 1.20 на стр.75 оригинала), сравнительно с ее нормальным использованием. Рассмотрим класс complex:

class complex (*

double real, imag; // по умолчанию private

public:

...

complex() (* real = imag = 0; *) // встроенный конструктор

complex(double r, double i = 0) (* // еще один

real = r; imag = i;

*)

...

*)

Данный класс был создан только для примера. Онотличен от класса complex из библиотеки исполняющей системы.

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

complex AddComplex(complex c1, complex c2);

однако будет более естественным иметь возможность записать:

complex c1(0,1), c2(1,0), c3

c3 = c1 + c2;

вместо

c3 = AddComplex(c1, c2);

Операция + легко может быть перегружена, есливключить в класс complex следующее объявление:

friend complex operator +(complex c1, complex c2*);

и сделав его определение (возможно, встроенное) следующим образом:

complex operator +(complex c1, complex c2)

(*

return complex(c1.real + c2.real, c1.imag + c2.imag); *)

Операции-функции

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

c3 = c1.operator + (c2); // то же, что c3 = c1 + c2

В отличие от new и delete, которые имеют своисобственные правила (см. следующий раздел), операция-функция должна быть либо не-статической функцией-компонентом, либо иметь как минимум один аргумент типа класса. Операций-функции =, (), [] и -> должны являться нестатическими функциями-компонентами.

Перегруженные операции и наследование

За исключением операции-функции присвоения =() (см. раздел "Перегрузка операции присвоения =" на стр.127 оригинала) все функции операций для класса X наследуются классом, производным от X, согласно стандартным правилам разрешения для перегруженных функций. Если Х является базовым классом для Y, перегруженная функция операции для Х может далее быть перегружена для Y.

Перегрузка new и delete

Операцииnew и delete могут быть перегружены таким образом, чтобыдаватьальтернативныеварианты подпрограммы управления свободной памятью (кучей). Определяемая пользователем операция new должна возвращать void* и иметь в качестве первого аргумента size_t. Определяемая пользователем операция delete должна иметь тип void и первый аргумент void*; второй аргумент, типа size_t, является опциональным.

Тип size_t определяется в stdlib.h.

Например,

#include <stdlib.h>

class X (*

...

public:

void* operator new(size_t size) (* return

newalloc(size);*)

void operator delete(void* p*) (*newfree(p); *)

X() (* /* здесь инициализация */

X(char ch) (* /* здесь тоже */ *)

-X() (* /* очистка */ *)

...

*);

Аргумент size задает размер создаваемого объекта, а newalloc и newfree это определяемые пользователем функции распределения и отмены распределения памяти. Вызовы конструктора и деструктора для объектов класса Х (или объектов, производных от Х, для которых не существует собственных перегруженных операций new и delete) приведет к запуску соответствующихопределяемых пользователем X::operator new() и X::operator delete(), соответственно.

Операции-функции X::operator new иX::operator delete являются статическими компонентами Х, как при явном объявлении их static, так и без него, поэтому они не могут быть виртуальными функциями.

Стандартные, предопределенные (глобальные) операции new и delete могут при этом также использоваться в контексте Х, как явно с операциямиглобального контекста (::operator new и ::operator delete), так и неявно, при создании и разрушении объектов классов, отличных от класса Х и не являющихся производными от класса Х. Например, можно использовать стандартныеnew иdeleteпри определении перегруженных версий:

void* X::operator new(size_t)

(*

void* ptr = new char[s]; // вызов стандартной new

...

return ptr;

*)

void X::operator delete(void* ptr)

(*

...

delete (void*) ptr; // вызов стандартной delete

*)

Причинойтого, что размер аргумента определяется size, является то,что классы, производные от Х, наследуют X::operator new. Размер объектапроизводного классаможетсущественно отличаться от размера, определяемого базовым классом.

Перегрузка унарных операций

Перегрузка префикснойили постфиксной унарной операции выполняется при помощи объявления не-статической функции компонента, не принимающей никакихаргументов, либо при помощи объявления функции, не являющейся функцией-компонентом принимающей один аргумент. Если @ представляет собой унарную операцию, то @x и x@ можно интерпретировать как x.operator@() и operator@(x), соответственно, в зависимости от объявления. Если объявление было сделано в обеих формах, то разрешение неоднозначностизависит от переданных при вызове операции стандартных аргументов.

Следует быть внимательным при перегрузке ++ и --, поскольку постфиксное и префиксное использование не может быть определено в перегруженной функции. Например,

class X (*

...

X operator ++() (* /* здесь подпрограмма инкремента X * / *)

*)

...

X x, y;

y = ++x; // то же, что и y = x++ !

Перегрузка бинарных операций

Перегрузка бинарной операции выполняется при помощи объявления не-статической функции компонента, принимающей один аргумент, либо при помощи объявления не являющейся компонентом функции (обычно friend), принимающей два аргумента. Если @ представляет собой бинарную операцию, тоx@y можно интерпретировать либо как x operator@(y), либо как operator@(x,y), в зависимости от выполненных объявлений. Если объявлены обе формы, то разрешение неоднозначности зависитот переданныхпри вызове операции стандартных аргументов.

Перегрузка операции присвоения =

Операцияприсвоения = может быть перегружена только при помощи объявления не-статической функции-компонента. Например,

Внимание : пример программы смотрите в файле struct.app

Данный код, совместно с объявлениями

String::operator=(), позволяет выполнять строковые присвоения str1 = str2, как это делается в прочих языках программирования. Вотличие от прочих функций операций, функция операции присвоения не может наследоваться производными классами. Если для какого-либо класса Х не существует определяемой операции =, то операция = определяется по умолчанию как покомпонентное присвоение компонентов класса Х:

X& X::operator = (const X& source)

(*

// покомпонентное присвоение

*)

Перегрузка операции вызова функции ()

Вызов функции

первичное-выражение(<список-выражений>)

рассматривается в качестве двоичной операции с операндами первичное-выражение и список-выражений (возможно, пустой). Соответствующая функция операции это operator(). Данная функция может являться определяемой пользователем для класса Х (и любых производныхклассов) только в качестве не-статической функции-компонента. Вызов x(arg1, arg2), где x есть объект класса Х, интерпретируется в таком случае как x.operator()(arg1,arg2).

Перегрузка операции индексирования []

Аналогичным образом, операция индексирования

первичное-выражение [выражение]

рассматривается как двоичнаяоперация с операндами первичное-выражение и выражение. Соответствующая функция операции это operator[]; она может быть определена пользователем для класса Х (и любых производных классов) только посредством не-статической функции-компонента. Выражение x[y], где x это объект класса Х, интерпретируется в данном случае как x.operator[](y).

Перегрузка операции доступа к компоненту класса ->

Доступ к компоненту класса при помощи

первичное-выражение->выражение

рассматривается как унарнаяоперация. Функция operator-> должна рассматриваться как не-статическая функция-компонента. Выражение x->m, где x это объект класса (*, интерпретируетсякак (x.operator->())->m, таким образом, что operator-> () должен либо возвращать указательна объект данного класса, либо возвращать объект класса, для которого определяется operator->.

Виртуальные функции -------------------------------

Виртуальные функциипозволяют производным классам обеспечивать разные версии функциибазового класса. Вы можете объявить виртуальную функцию в базовом классе и затем переопределить ее влюбом производном классе, даже если число и тип ее аргументов остается без изменений. Вы также можете объявить функции int Base::Fun (int) и int Derived::Fun (int), даже если они не являются виртуальными. Версия базового класса доступна объектам производного класса через переопределение контекста. Если они являются виртуальными, то доступна только функция, связанная с фактическим типом объекта.

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

Говорят,что переопределенная функция переопределяет функцию базового класса. Для объявления виртуальной функции служит спецификатор virtual. Спецификатор virtual подразумевает компонентство в классе, поэтому виртуальная функция не может быть глобальной (не являющейся компонентом) функцией.

Если базовый класс В содержит виртуальную функцию vf, и класс D, являющийся производным от класса B, содержит функцию vf того же типа,то если функция vf вызывается дляобъекта d или D, выполняется вызов D::vf, даже если доступ определен через указатель или ссылку на B. Например,

struct B (*

virtual void vf1();

virtual void vf2();

virtual void vf3();

void f();

*)

class D : public B (*

virtual void vf(); // спецификатор virtual допустим, но // избыточен

void vf2(int); // не virtual, поскольку здесь

// используется другой список аргументов

char f(); // так нельзя: изменяется только тип

// возврата

void f();

*);

void extf()

(*

D d; // объявление объекта D

B* bp = &d; // стандартное преобразование из D* в B* bp->vf1(); // вызов D::vf1

bp->vf2(); // вызов B::vf2, так как vf2 из D имеет // отличные аргументы

bp->f(); // вызов B::f (не виртуальной)

*)

Переопределяющаяфункция vf1 в D автоматически становится виртуальной. Спецификатор virtual может быть использован в определении переопределяющейфункции в производном классе, но на самом деле он является в данном случае избыточным.

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

Примечание:

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

Виртуальная функция в базовом классе, как и все функции -компоненты базового класса, должна быть определена, а если не определена, то объявлена как функция без побочного эффекта ("чистая").

class B (*

virtual void vf(int) = 0;// = 0 означает "чистую" функцию

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

Если виртуальная функция определена в базовом классе, то нет необходимости ее переопределения в производном классе. При вызовах будет просто вызвана соответствующая базовая функция.

Виртуальные функции заставляют определенным образом расплачиваться за свою универсальность: каждый объект производного класса должен содержать указатель на таблицу функций с тем, чтобы во время выполнения программы вызвать нужную (поздняя компоновка). См. главу 5, в документе "Начало работы".

Абстрактные классы

Глава 5 документа "Начало работы" приводит пример абстрактного класса в действии.

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

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

class shape (* // абстрактный класс

point center;

...

public:

where() (* return center; *)

move(point p) (* center = p; draw(); *)

virtual void rotate(int) = 0; // чистая виртуальная функция

virtual void draw() = 0; // чистая виртуальная функция

virtual void hilite() = 0; // чистая виртуальная функция

...

*)

shape x; // ошибка: попытка создания объекта абстрактного

// класса

shape* sptr; // указатель на абстрактный класс допустим

shape f(); // ошибка: абстрактный класс не может являться

// типом возврата

int q(shape s); // ошибка: абстрактный класс не может являться

// типом аргумента функции

shape& h(shape&);// ссылка на абстрактный класс в качестве типа

// возврата или аргумента функции допустим

Предположим, что D является производным классом непосредственно от абстрактного базового класса B. Тогда для каждой чистой виртуальной функции pvf в B либо D должен обеспечивать определение pvf, либоD должен объявлять pvf как чистую функцию.

Например, с использованием показанного выше класса shape:

class circle : public shape (* // circle является производным // от абстрактного класса

int radius; // private

public:

void rotate(int) (* *) // определяется виртуальная

// функция:

// действия по вращению окруж-

// ности отсутствуют

void draw(); // circle::draw должна быть

// где-либо определена

void hilite() = 0; // переопределение функции

// как "чистой"

Функций-компоненты могут быть объявлены из конструктора абстрактногокласса, но вызов чистой виртуальной функции непосредственно или косвенно из такого конструктораприводит к ошибке времени выполнения.

Контекст С++

Лексические правилаопределения контекста в С++, безотносительно к контексту класса, следуют общим правилам С, но с учетом того, что С++, в отличие от С, позволяет объявлениякак данных, так и функций везде, где может находиться оператор. Такая гибкость означает, что необходима осторожность при интерпретации таких фраз, как "объемлющий контекст" и "точка объявления".

Контекст класса

Имя М компонента класса Х имеет контекст класса "локальный по отношению Х"; оно может использоваться в следующих ситуациях:

- в функциях-компонентах Х

- в выражениях типа x.M, где x есть объект Х

- в выражениях типа xptr->M, где xptr есть указатель объекта Х

- в выражениях типа X::M или D::M, где D есть производный класс от X

- в ссылках вперед в пределах класса, которому принадлежит компонент

Классы, перечислимые данные или имена typedef, объявленные в пределах класса Х, либо имена функций, объявленные как "друзья" Х, не являются компонентами Х; их имена просто имеют объемлющий контекст.

Скрытые имена

Имя может бытьскрытоявным объявлением того же имени в объемлющем блоке или в классе. Скрытый компонент класса тем не менее остается доступным при помощи модификатора контекста, заданного с именем класса X:M. Скрытое имя с контекстом файла (глобальное) позволяет ссылку на него при помощи унарной операции ::, например ::g. Имя класса Х может быть скрыто именем объекта, функции, либо нумератора, заданного в контексте Х, независимо от последовательности объявления имен. Однако, имя скрытого класса Х доступно прииспользовании префикса Х с соответствующим ключевым словом class, struct или union.

Точка объявления имени х находится непосредственно после его полного объявления, но до инициализатора, если таковой существует.

Краткое изложение правил определения контекста С++

Следующие правила применимы ко всем именам, включая имена typedef и имена классов, при условии, что то или иноеимя допустимо в С++ в конкретном обсуждаемом контексте:

1. Сначала само имя проверяется на наличие неоднозначностей. Если в пределах контекста неоднозначности отсутствуют, то инициируется последовательность доступа.

2. Если ошибок управления доступа не обнаружено, то проверяется тип объекта, функции, класса, typedef, и т.д.

3. Если имя используется вне какой-либо функции или класса, либо имеет префикс унарной операции контекста доступа ::, и если имя не квалифицировано бинарной операцией ::или операциямивыборакомпонента . или ->, то это имя должно быть именем глобального объекта, функции или нумератора.

4. Если имя n появляется в одном из видов: X::n, x.n (где x это объект класса Х или ссылка на Х), либо ptr->n (где ptrэто указатель на Х),то n является именем компонента Хили компонентом класса, производным от которого является Х.

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

6. Любое не рассмотренное до сих пор имя, используемое в качестве имени нестатической функции компонента класса Х, должно быть объявлено в блоке, в котором оно встречается, либо в объемлющем блоке, быть компонентом класса Х или базового относительно Х класса, либо быть глобальным именем. Объявление локального имени n скрывает объявления n в объемлющих блоках,компонентах класса- функциях и глобальных объявлениях n. Объявление имени компонента скрывает объявления этого имени в базовых классах.

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

8. Инициализатор конструктора (см. "инициализатор-конструктора" в описании синтаксиса декларатора класса в таблице

1.12 на стр.37 оригинала) вычисляется в контексте самого внешнего блока конструктора, и поэтому разрешает ссылки на имена аргументов конструктора.

Директивы препроцессора Turbo C++

Хотя Turbo C++ использует использует интегрированный однопроходный компилятор как при работе в интегрированной среде разработки (IDE), так и при вызове компилятора из командной строки, полезно тем не менее сохранить терминологию, сохранившуюся от более ранних, многопроходных компиляторов. В случае последних на первом проходе обработки исходного текста программы выполняется подключение всех имеющихсявключаемых файлов, проверка всех условных директив компиляции, расширение всех имеющихся макросов и получение промежуточного файла для обработки последующими проходами компилятора. Посколькукак интегрированная среда разработки, так и версия командной строки Turbo C++ выполняют первый проход, не создаваяпри этом каких-либо промежуточных файлов, Turbo C++ включаетв себя независимый препроцессор, CPP.EXE, который имеет на выходе такой промежуточный файл. CPP полезен на стадии отладки, посколькупоказывает в чистом виде результаты работы директив включения, условных директив компиляции и сложных макрорасширений.

CPP позволяет обращение к документации по нему в диалоговом режиме.

Следующее обсуждение директив препроцессора, их синтаксис и семантика, применимы, следовательно, как к самому препроцессору CPP, так и к его функциям, встроенным в компиляторы Turbo C++.

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

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

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

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

- Установка условной компиляции для улучшения мобильности получаемых кодов и для целей отладки.

Директивы препроцессора обычно помещаются в начало исходного кода, но допустимы в любой точке программы.

Любая строка с ведущим символом # рассматриваетсякак директива препроцессора, еслитолько# не входит в строковый литерал, символьную константу или комментарий. Ведущему символу # может предшествовать, либо следовать за ним,пробельные символы (за исключением символа новой строки).

Полный синтаксис препроцессора Turbo C++ показан в следующей таблице:

Синтаксис директив препроцессора Turbo C++ Таблица 1.23

файл-для-препроцессора:

группа

группа:

часть группы

группа часть-группы

часть-группы:

<лексемы-препроцессора> новая-строка

if-раздел

управляющая строка

if-раздел:

if-группа <elif-группы> <else-группа> endif-строка

if-группа:

#if выражение-типа-константы новая-строка <группа>

#ifdef идентификатор новая-строка <группа>

#ifndef идентификатор новая-строка <группа>

elif-группы:

elif-группа

elif-группы elif-группа

elif-группа:

#elif выражение-типа-константы <группа>

else-группа:

#else новая-строка <группа>

endif-строка:

#endif новая-строка

управляющая-строка:

#include лексемы-препроцессора новая-строка

#define идентификатор список-замены новая-строка

#define идентификатор левая-круглая-скобка

<список-идентификаторов>) список-замены новая-строка

#undef идентификатор новая-строка

#line <лексемы-препроцессора> новая-строка

#pragma <лексемы-препроцессора> новая-строка

#pragma warn действие сокращение новая-строка

#pragma inline новая-строка

? новая-строка

действие: одно из

+ - .

сокращение:

amb ampapt aus big cincpt

def dupelf mod par piapro

rch retrng rpt rvf sigstr

stu stvsus ucp use volzst

левая-круглая-скобка:

символ левой круглой скобки без предшествующих пробельных символов

список-замены:

<лексемы-препроцессора>

лексемы-препроцессора:

имя-заголовка (только для директивы #include)

идентификатор (без различения ключевого слова)

константа

строковый-литерал

операция

пунктуатор

любой не-пробельный символ, не относящийся к предыдущим пунктам

имя-заголовка:

<последовательность-символов-заголовка>

последовательность-символов-заголовка:

символ-заголовка

последовательность-символов-заголовка символ-заголовка

символ-заголовка:

любой символ из исходного множества символов, за исключением символа новой-строки (\n) или символа "больше чем" (>).

новая-строка:

символ новой строки

Пустая директива #

Пустая директива состоитиз строки, вкоторой содержится единственныйсимвол #. Эта директива всегда игнорируется препроцессором.

Директивы #define и #undef

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

Простые макросы #define

В простых случаях, без параметров, синтаксис данной директивы следующий:

#define идентификатор_макроса <последовательность_лексем>

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

Любые вхожденияидентификаторамакроса, обнаруженное в литеральных строках, символьных константах или комментариях расширению не подлежат.

Пустая последовательность лексем позволяетэффективное удаление всех найденных идентификаторов макросов из исходного кода:

#define HI "Добрый день!"

#define empty

#define NIL ""

...

puts(HI); /* расширяется в: puts("Добрый день!"); */

puts(NIL); /* расширяется в: puts(""); */

puts("empty"); /* расширения empty не происходит ! */

/* расширение empty не будет выполнено и в комментариях! */

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

#define GETSTD #include <stdio.h>

...

GETSTD /* ошибка компиляции */

GETSTD будет расширен в #include<stdio.h>. Однако, препроцессор не станет сам обрабатывать эту вполне допустимую в других условиях директиву, а передаст ее в таком виде компилятору. Компилятор воспримет#include <stdio.h> как недопустимый ввод. Макрос не может быть расширен во время собственногорасширения. Поэтому выражения типа #define A A недопустимы вследствие неопределенности результата.

Директива #undef

Можно отменить определение макроса при помощи директивы #undef:

#undef идентификатор_макроса

Данная строка удаляетлюбую ранее введенную последовательность лексем из идентификатора макроса;определение макроса теряется, и идентификатор его становится неопределенным.

Макрорасширения внутри строк #undef не выполняются.

Состояние определенности и неопределенности является важным свойством идентификатора, независимо от его фактического определения. Условные директивы препроцессора #ifdef и #ifndef, которые служат для проверки того, является ли идентификатор в текущий момент определенным, или нет, представляют собой гибкий механизм управления многими аспектами компиляции.

После того, как идентификатор макроса стал

неопределенным, он может бытьдалеепереопределендирективой

#define, с использованием той же самой или другой последовательности лексем.

#define BLOCK_SIZE 512

...

buff = BLOCK_SIZE*blks; /* расширяется в: 512*blks */ ...

#undef BLOCK_SIZE

/* использование BLOCK_SIZE теперь невозможно - это "неизвестный" препроцессору идентификатор */

...

#define BLOCK_SIZE 128 /*переопределение размера блока*/

...

buf = BLOCK_SIZE*blks; /* расширяется в: 128*blks */

...

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

#ifndef BLOCK_SIZE

#define BLOCK_SIZE 512

#endif

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

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

Программисты, привыкшие работать на языке ассемблера, должны преодолеть желание написать:

#define BLOCK_SIZE = 512 /* почему последовательность лексем включает символ = */

Опции -D и -U

Определение и отмена определения идентификаторов выполняется также при помощи опций компилятора командной строки - D и -U (см. Главу 4,"Компилятор командной строки" в Руководстве пользователя). Идентификаторы могут быть определены, но не могут бытьявно отменены, при помощи меню интегрированной среды разработки Options \! Compiler \! Defines (см. Главу 1,"Справочник по интегрированнойсредеразработки", также в Руководстве пользователя.)

Командная строка

tcc -Ddebug=1; paradox=0; X -Umysym myprog.c

эквивалентна помещению в программу строк:

#define debug 1

#define paradox 0

#define X

#undef mysym

Ключевые слова и защищенные слова

Допустимо, но не рекомендуется, использовать ключевые слова Turbo C++ в качестве идентификаторов макросов:

#define int long /* допустимо, но может привести к катастрофическим последствиям */

#define INT long /* допустимо и, вероятно, полезно */

Следующие предопределенные глобальные идентификаторы не могут появляться непосредственно следом за директивами #defineили #undef:

__STDC__ __DATE__

__FILE__ __TIME__

__LINE__

Отметим наличие в этих именах ведущих и хвостовых двойных символов подчеркивания.

Макросы с параметрами

Для определения макросов с параметрами используется следующий синтаксис:

#define идентификатор_макроса(<список-аргументов>) последовательность-лексем

Любая запятая в круглых скобках внутри аргумента рассматривается как часть аргумента, а не какразделитель аргументов.

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

Вызов таких макросов выполняется записью

идентификатор-макроса<пробельный-символ>(<список-фактическихаргументов>)

в последующем исходном коде. Синтаксис вызова аналогичен синтаксису вызова функций; действительно, многиестандартные библиотечные "функции" С реализованы в виде макросов. Однако, имеется ряд возможных различий, которые могут привести к случайным ошибкам (см. стр.140 оригинала).

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

Вызов макроса приводитк двум типамзамены. Во-первых, идентификатор макроса и заключенные в круглые скобки аргументы заменяются последовательностью лексем. Затем формальные аргументы, найденные в данной последовательности лексем, заменяются соответствующими фактическими аргументами из списка-фактических-аргументов. Например,

#define CUBE(x) ((x)*(x)*(x))

...

int n,y

n = CUBE(y):

дает в результате следующую замену:

n = ((y)*(y)*(y));

Аналогичным образом, последняя строка в

#define SUM ((a) + (b))

...

int i,j,sum;

sum = SUM(i,j);

при расширении даст sum = ((i)+(j)). Причина кажущегося избытка круглых скобок станет очевидной, если рассмотреть пример:

n = CUBE(y+1);

Без внутренней пары круглых скобок в определении расширение даст запись: n=y+1*y+1*y+1, что при лексическом анализе равно:

n = y + (1*y) + (1*y) + 1; // если y не равен 0 или -3, то в // куб возводится (y+1) !

Как и в случае простых макроопределений, производится повторное сканирование текста для определения необходимости повторных макрорасширений получившихся макро-идентификаторов.

При использовании макросов со спискамиаргументов следует обратить внимание на следующие моменты:

1. Вложенные круглые скобки и запятые:

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

#define ERRMSG(x, str) showerr("Error",x,str)

#define SUM(x,y) ((x) + (y))

...

ERRMSG(2, "Press Enter, then Esc");

// расширится в: showerr("Error",2,"Press Enter, then Esc"); */ return SUM(f(i,j), g(k.l));

// расширится в: return ((f(i,j)) + (g(k,l))); */

2. Склеивание лексем при помощи ##: можно выполнить склеивание (слияние) двух лексем, разделив их символами ## (и плюс опциональными пробельными символами с каждой стороны). Препроцессор удаляет пробельные символы и##, объединяядве отдельные лексемыв одну новуюлексему. Это средство можно использовать для конструированияидентификаторов; например, выполнив определение

#define VAR(i,j) (i##j)

и затем вызвав VAR(x,6), можно получить расширение (x6). Этот метод заменяет старый (не обеспечивающий мобильность кода) метод использования (i/**/j).

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

#define TRACE(flag) printf(#flag "=%d\n",flag)

фрагмент кода

int highval = 1024;

TRACE(highval);

станет равным

int highval = 1024;

printf("highval" "= %d\n", highval);

что в свою очередь будет рассматриваться как

int highval = 1024;

printf("highval=%d\n", highval);

4 Символ обратной наклонной черты для продолжения строки: длинная последовательность лексем может продлитьстрокупри помощи обратной наклонной черты (\). Символы обратной наклонной черты и новой строки оба вырезаются, и в результате образуется фактическая последовательность лексем, используемая в расширении:

#define WARN "фактически это одно\

строчное сообщение"

...

puts(WARN);

/* на экране будет: фактически это однострочное сообщение */

5. Побочные эффекты и прочие опасности: схожесть между вызовами макросов и функциями иногда скрывает различия между ними. При вызове макроса отсутствует встроенный контроль типов данных, поэтому различиев типах данных формального и фактического аргументов может вызвать непредсказуемые результаты, причину которых нелегко установить, причем относительно такой ошибки не будет выдано никаких предупреждений. При вызовах макросов могут также возникнуть нежелательные побочные эффекты, особенно когдафактический аргумент вычисляется более одного раза. Сравните CUBE и cube в следующем примере:

int cube(int x) (*

return x*x*x;

*)

#define CUBE(x) ((x)*(x)*(x))

...

int b =0, a = 3;

b = cube(a++);

/* cube() передается фактический аргумент = 3; поэтому b = 27, и теперь a = 4 */

a = 3;

b = CUBE(a++);

/* расширяется в: ((a++)*(a++)*(a++)); и теперь a = 6 */

Итоговое значение b зависит от того, что компилятор делает с расширенным выражением.

Включение файлов директивой #include

Директива #include подключает к исходному коду заданные в ней файлы, известные как включаемые файлы, файлы заголовковили заголовки. Синтаксис этой директивы имеет три формы:

#include <имя_заголовка>

#include "имя_заголовка"

#include идентификатор_макроса

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

Третий вариант записи предполагает, что ни символ <, ни символ " не являются первым не-пробельным символом, следующим за #include; кроме того, предполагается, что существует такое макроопределение, которое расширит идентификатор макроса в допустимое, следующее за разделителем имя заголовка в формате либо <имя_заголовка>, либо "имя_заголовка".

Первый и второй варианты предполагают, что попыток макрорасширений сделано не будет; другими словами, имя_заголовка никогда не сканируется в поискахидентификаторов макросов. Имя_заголовка должно быть допустимым именем файла DOS с расширением (традиционно файлы заголовка имеют расширение .h) и опциональнымименемпути доступа к немус соответствующими разделителями.

Препроцессор удаляет строку #include и заменяет ее, начиная с текущей строки исходного кода, полным текстом файла заголовка. Сам исходный код остается без изменений,однакокомпилятор "видит" весь расширенный текст целиком. Таким образом, помещение в текст директивы #include может повлиять на контекст и продолжительность жизни любых идентификаторов во включаемых файлах.

Если поместить в имя_заголовка полное имя пути доступа к файлу, то поиск файла будет выполнентольков указанной таким образом директории.

Различиемежду форматами <имя_заголовка> и "имя_заголовка" заключается в алгоритме поиска включаемого файла, применяемом в каждом случае; эти алгоритмы описаны в следующих двух разделах.

Поиск файла заголовка при формате <имя_заголовка>

Вариант <имя_заголовка>задает стандартный включаемый файл; поиск последовательно выполняется во всех включаемых директориях в той последовательности, в которой они определены. Если ни в одной из этих директорий по умолчанию искомый файл не найден, то выдается сообщение об ошибке.

Поиск файла заголовка при формате "имя_заголовка"

Вариант "имя_заголовка" задает включаемый файл, создаваемый пользователем; сначала выполняется его поиск в текущей директории (обычно в той директории, в которой находится исходный компилируемый файл). Если там файл не найден, то поиск продолжается во всех включаемых директориях, как в случае формата <имя_заголовка>.

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

#include <stdio.h>

/* заголовок из стандартной включаемой директории */

#define myinclude"c:\tc\include\mystuff.h"

/* Примечание: здесь допустимы одинарные символы обратной

наклонной черты; в операторе С пишется:

"c:\\tc\\include\\mystuff.h" */

#include myinclude

/* макрорасширение */

#include "myinclude.h"

/* макрорасширение отсутствует */

После расширения второй оператор#include заставит препроцессор искать нужный файл в C:\TC\INCLUDE\mystuff.h, и нигде более. Третий пример #includeзаставляет препроцессор выполнить поискmyinclude.h сначала в текущей директории, а затем во включаемых директориях.

Условная компиляция

Turbo C++ поддерживаетусловную компиляцию путем замены соответствующих строк исходного кода пустой строкой. Игнорируемые таким образом строки это те строки, что начинаются с символа # (за исключением директив #if, #ifdef, #ifndef, #else, #elif и #endif), а также любые строки, которые в результате выполнения директив не должны компилироваться. Все директивы условной компиляции должны завершаться в том же исходном или включаемом файле, где находится их начало.

Директивы условной компиляции #if, #elif, #else и #endif

Директивы условной компиляции #if, #elif, #else и #endif работают аналогично обыкновенным условным операторам

С.Они используются следующим образом:

#if выражение-1-типа-константы

<раздел-1>

<#elif выражение-2-типа-константы новая-строка раздел-2>

...

<#elif выражение-n-типа-константы новая-строка раздел-n>

<#else последний-раздел>

#endif

...

Если выражение-1-типа-константы(для котороговыполняется макрорасширение) дает ненулевое значение (истина), то строки кода (возможно, пустые), представленногоразделом-1, которые могут представлять собой как командные строки препроцессора, так и обычные строки исходного кода, обрабатываются препроцессором и соответствующим образом передаются компилятору Turbo C++. В противном случае, если выражение-1-типа-константы дает нулевое значение (ложь), раздел-1игнорируется (макрорасширение и компиляция данного раздела не выполняются).

В случае "истина" после обработки раздела-1 препроцессором управление передается соответствующейдирективе #endif (которая заканчивает даннуюусловную конструкцию) и продолжается в следующем-разделе. В случае "ложь" управление передается следующей строке #elif (если она определена в данной конструкции),где вычисляетсявыражение-2-типа-константы. В случае "истины" обрабатывается раздел-2, после чего управление передается соответствующей директиве #endif, и т.д.,до тех пор, пока не будет достигнута последняя директива #else или #endif. Опциональная директива #else используется в качестве альтернативного условия в том случае, если все предыдущие проверки дали значение "ложь". Последовательность условных директив заканчивается директивой #endif.

Обработанный препроцессором раздел может в свою очередь содержать вложенные на любую глубину условные предложения, причем каждой директиве #if должна соответствовать закрывающая директива #endif.

Итоговым результатом вышеописанного сценария является то, что для дальнейшей обработки передается только один раздел (возможно, пустой). Опущенныеразделы служат только для отслеживания возможных вложенных условных конструкций, так что каждая директива #if должна обязательно иметь соответствующую ейзавершающую директиву #endif.

Проверяемые выражения-типа-константы при вычислении должны давать целочисленную константу.

Операция defined

Операция defined дает альтернативный, более гибкий способ проверки того, определены ли комбинации идентификаторов, или нет. Данная операция допустима только в выражениях #if и #elif.

Выражение defined(идентификатор)или defined идентификатор (скобки необязательны) дает 1 (истина), если данное символическое имя было ранее определено (при помощи директивы # defined) иэто определение не было впоследствии отменено (при помощи #undef); в противном случае оно дает 0 (истина). Поэтому директива

#if defined(mysym)

это то же, что

#ifdef mysym

Преимущество заключается в том, что можно использовать defined циклически в сложном выражении, следующем за директивой #if, например

#if defined(mysym) && !defined(yoursym)

Условные директивы #ifdef и #ifndef

Условные директивы #ifdef и #ifndef позволяют проверить, определен лив текущий момент данный идентификатор, то есть была ли обработана предыдущаядиректива #define для данного идентификатора и продолжает ли она действовать в текущий момент.

Строка

#ifdef идентификатор

имеет точно такой же эффект, что и

#if 1

если идентификатор в текущий момент определен, и такой же эффект, что и

#if 0

если идентификатор в текущий момент не определен.

#ifndef, напротив, дает значение "истина", если идентификатор "не определен", поэтому строка

#ifndef идентификатор

имеет точно такой же эффект, что и

#if 0

если идентификатор в текущий момент определен, и такой же эффект, что и

#if 1

если идентификатор в текущий момент не определен.

Синтаксис следует синтаксису директив #if, #elif, #else и #endif, описанному в предыдущем разделе.

Идентификатор, определенный как имеющий пустое (NULL) значение, считается определенным.

Директива управления нумерацией строк #line

Директива #lineслужитдля заданияпрограмме способа нумерации строк, используемой при создании перекрестных ссылок и при выдаче сообщений об ошибках. Если программасостоит из разделов, взятых из других программных файлов, часто бывает полезно обозначить такиеразделы номерами строк, взятыми из соответствующего исходного текста, а не обычными последовательными номерами строк составной программы. Синтаксис директивы следующий:

#line целочисленная-константа <"имя-файла">

и обозначает, что следующая исходная строка берется начиная с номера строки, заданного целочисленной-константой, из файла, заданного "именем-файла". После того, как имя-файла было однажды задано, все последующие команды #line, относящиеся к данному файлу, может опустить явный аргумент имя-файла. Например,

/* TEMP.C: пример директивы #line */

#include <stdio.h>

#line 4 "junk.c"

void main()

(*

printf(" in line %d of %s",__LINE__,__FILE__);

#line 12 "temp.c"

printf("\n");

printf(" in line %d of %s",__LINE__,__FILE__);

#line 8

printf("\n");

printf(" in line %d of %s",__LINE__,__FILE__);

*)

Включение stdio.h означает, что на выходе препроцессора будет нечто большее.

Если запустить TEMP.C через CPP (cpp temp), то на выходе получится файл TEMP.I, который выглядит так:

temp.c 1:

c:\borland\tc\cpp\include\stdio.h 1:

c:\borland\tc\cpp\include\stdio.h 2:

c:\borland\tc\cpp\include\stdio.h 3:

...

c:\borland\tc\cpp\include\stdio.h 212:

c:\borland\tc\cpp\include\stdio.h 213:

temp.c 2:

temp.c 3:

junk.c 4: void main()

junk.c 5: (*

junk.c 6: printf(" in line %d of %s",6,"junk.c");

junk.c 7:

temp.c 12: printf("\n");

temp.c 13: printf(" in line %d of %s",13,"temp.c");

temp.c 14:

temp.c 8: printf("\n");

temp.c 9: printf(" in line %d of %s",9,"temp.c");

temp.c 10: *)

temp.c 11:

Если вызатем компилируете TEMP.C, то получится следующий выход:

in line 6 of junk.c

in line 13 of temp.c

in line 9 of temp.c

Макросы расширяются в аргументах #line, как в директивах #include.

Прежде всего назначение директивы #line заключается в использовании ее в утилитах, имеющих на выходе коды С, а не в кодах, создаваемых человеком "вручную".

Директива #error

Директива #error имеет следующий синтаксис:

#error сообщение-об-ошибке

Директива генерирует сообщение:

Error: имя-файла номер-строки : Error directive: сообщение

Данная директива обычно встраивается в условные конструкции препроцессора, которые отслеживают какие-либо нежелательные условия времени компиляции.Обычноэто условие "ложно". Если условие "истинно", то компилятор может выдать сообщение об ошибке и прекратитьработу. Для этого директива# error помещается в условную ветвь, которая дает для искомого нежелательного условия результат "истина".

Например, вы определили #define MYVAL, принимающую значения 0 или 1. Затем можновключить в исходный код условную директиву, которая будет проверять MYVAL на предмет неверного значения:

#if (MYVAL != 0 && MYVAL != 1)

#error MYVAL must be defined to either 0 or 1

#endif

Директива #pragma

Директива #pragma позволяет использовать специфичные для конкретных реализаций директивы в форме

#pragma имя-директивы

При помощи #pragma Turbo C++позволяет определить любые желаемые директивы, не обращаясь дляэтогок другим, поддерживающим их компиляторам. Если компилятор не поддерживает данное имя-директивы, то он просто игнорируетдирективу #pragma, не выдаваяпри этом никаких сообщений об ошибкахили предупреждений.

Turbo C++ поддерживает следующие директивы #pragma:

- #pragma argsused

- #pragma exit

- #pragma inline

- #pragma option

- #pragma saveregs

- #pragma startup

- #pragma warn

Директива #pragma argsused

Директива #pragma argsused допустима только между определениями функций и действует только на следующую функцию. Она отменяет сообщение уровня предупреждения:

"Parameter name is never used in function имя-функции" ("имя параметра нигде не используется в функции имя-функции")

Директивы #pragma exit и #pagma startup

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

Синтаксис этих директив следующий:

#pragma exit имя-функции <приоритет>

#pragma startup имя-функции <приоритет>

Заданное имя-функции должно относиться к ранееобъявленной функции, не принимающей аргументов и возвращающей значение void; другими словами, эта функция должна быть объявлена как:

void func(void);

Опциональный параметр приоритет должен являться целым числом в диапазоне от 64 до 255. Старшим приоритетом является 0. (Приоритеты от 0 до 63 используются библиотеками С и не должны использоваться пользователем). Функции со старшими приоритетами вызываются первыми при загрузке программы и последними при выходе из нее. Если приоритет не задан, то по умолчанию он равен 100. Например,

#include <stdio.h>

void startFunc(void)

(*

printf("Startup function.\n");

*)

#pragma startup startFunc 64

/* приоритет 64 --> вызывается при загрузке первой */

void exitFunc(void)

(*

printf("Wrapping up execution.\n");

*)

#pragma exit exitFunc

/* приоритет по умолчанию равен 100 */

void main(void)

(*

printf(This is main.\n");

*)

Отметим, что имя функции, используемой в #pragma startupили exit, должно быть определено (или объявлено) до того,как встретится соответствующая строка с директивой #pragma.

Директива #pragma inline

Данная директиваэквивалентна опции компилятора командной строки -B или соответствующей опции интегрированной среды Turbo. Она сообщаеткомпилятору, что программа содержит встроенные ассемблерные коды (см. главу 6, "Интерфейс с языком ассемблера"). Синтаксис ее следующий:

#pragma inline

Эту директиву лучше всего помещать вверху файла, поскольку, встретив директиву #pragma inline, компилятор перезапускает себя с опцией -B. Фактически можно опустить и опцию -В, и директиву #pragma inline, и компилятор тем не менее выполнитперезапуск, когда встретит операторы asm. Назначение опции и директивы состоит в том, чтобы сэкономить время компиляции.

Директива #pragma option

Директива #pragma option используетсядля включения опций компилятора командной строки в код вашей программы. Синтаксис этой директивы следующий:

#pragma option [опции...]

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

Ниже приводятсяопции,которые не могут находиться в директиве pragma option:

-B (компиляция с использованием ассемблерных кодов)

-c (компиляция без компоновки)

-dxxx (определение макроса)

-Dxxx = ccc (определение макроса с текстом)

-efff (имя .EXE-файла fff)

-lfff (имя включаемой директории)

-Lfff (имя директории с библиотекой)

-lxset (опция компоновщика x)

-M (создание при компоновке .MAP-файла)

-o оверлеи

-Q EMS

-S (создание на выходе .ASM-файла и остановка)

-Uxxx (отмена определения макроса)

-V (virtual)

-Y (оверлеи)

Существует два состояния компилятора. В первом состоянии в директиву pragma option можно включить большее количество опций, нежели во втором. Первое состояние компилятора называется состоянием лексического анализа,а второе - состоянием кодирования.

Использование имени макроса, начинающегося двумя символами подчеркивания (которое может являться именем встроенного макроса), в директивах #if, #ifdef, #ifndef или #elifизменяет состояние компилятора на состояние кодирования.

Появление первой реальной лексемы (первого объявления

С) также изменяет состояние компилятора на кодирование.

Другими словами, можноиспользовать директивы #pragma, # include, #define и некоторые разновидности #if во время состояния лексического анализакомпилятора. Во время этой фазы вы имеете возможность при помощи #pragma option изменять опции командной строки.

В числоопций,которые могут быть заданы в #pragma option только в состоянии лексического анализа компилятора, входят:

-Efff (строка с ассемблерным именем)

-f* (любая опция плавающей точки, кроме -ff)

-l# (значащие символы идентификатора)

-m* (любая опция модели памяти)

-nddd (выходная директория)

-offf (имя выходного файла fff)

-u (использование символов подчеркивания в именах cdecl)

-z* (опция задания любого имени сегмента)

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

-1 Управление набором команд

-2 Управление набором команд

-a Управление выравниванием. (Отметим, что выравнивание компонентов структурыустанавливается в точке определения структуры, а не далее, при использовании этой структуры объектами.)

-ff Управление быстрыми операциями с плавающей точкой

-G Генерация кода, оптимизированного по быстродействию

-k Стандартное управление стековым фреймом

-N Управление контролем стека

-O Управление оптимизацией

-P Установка по умолчанию соглашений о связях Pascal

-r и -rd Управление регистровыми переменными

-v Управление отладкой по действиям

-y Управление строчной информацией

Следующие опциимогут изменяться в любой момент и оказывают немедленное воздействие на компилятор:

-A Управление ключевыми словами

-C Управление вложенностью комментариев

-d Слияние повторяющихся строк

-gn Остановка компиляции после n предупреждений

-jn Остановка компиляции после n ошибок

-K Тип char устанавливается как unsigned

-wxxx Предупреждение (то же самое, что и #pragma warn)

Любые из имеющих два переключающихся состояния опций (такие как -a или -K) могут быть переведены во включенное или выключенное состояние, как это делается в командной строке. Дополнительно имеется возможность задавать их с точкой (.), что устанавливает такие опции в состояние, задаваемое командной строкой.

Директива #pragma saveregs

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

Директива #pragma warn

Данная директива позволяет переопределять конкретные опции командной строки -wxxx (или управлять опцией Display Warnings в диалоговом поле Options \! Compiler \! Messages).

Например, если в вашем исходном коде имеются директивы

#pragma warn +xxx

#pragma warn -yyy

#pragma warn .zzz

то выдача предупреждения xxx будет разрешена (даже если в меню Options \! Compiler \! Messages она была переведена в состояние off), предупреждения yyy запрещена, а статус выдачи сообщения zzz будет восстановлен в то состояние, которое было к моменту начала компиляции файла.

Полный список трехбуквенных сокращений и сообщений, к которым они относятся, см. в Главе 4, "Компилятор командной строки" в Руководстве пользователя.

Предопределенные макросы

Turbo C++ имеет следующие предопределенные глобальные идентификаторы. За исключением __cplusplus, каждое из них и начинается, и заканчиваетсядвумя символами подчеркивания (__). Эти макросы также называют буквальными константами.

__CDECL__

Данный макрос специфичен для Turbo C++. Он сообщает о том, что флаг -p не использовался (меню Cflling Conventions...C) : он устанавливается равным целочисленной константе 1, если -pне использовался; в противном случае он неопределен.

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

__COMPACT__ __MEDIUM__

__HUGE__ __SMALL__

__LARGE__ __TINY__

Для конкретной компиляции определенным является только один из этих макросов; прочие, по определению, не определены. Например, если при компиляциивыбрана модель памяти small, то макрос __SMALL__ определен, а остальные неопределены, поэтому директива

#if defined(__SMALL__)

даст значение "истина", а

#if defined(__HUGE__)

либо любая другая из оставшихся) даст значение "ложь". Фактическое значение любого из этих макросов, когда он определен, равно 1.

__cplusplus

Данный макрос специфичен для Turbo C++. Он позволяет написать модуль, который в некоторых случаях будет компилироваться в С, а в некоторых - в С++.Использование условных директив компиляции позволяет управлять, какие части программы для С и С++ будут включены в компиляцию.

__DATE__

Данный макрос дает дату начала обработки препроцессором данного исходного файла (в виде строкового литерала).

Каждое включение __DATE__ в данный файл дает одно и то же значение, независимо от того, сколько времени продолжается обработка файла препроцессором. Дата имеет форму mmmddyyyy,где mmm это месяц (Jan, Feb и т.д.), dd равно числу месяца (от 1 до 31, причем если это число меньше 10, то первый символ d равен пробелу), а yyyy это год (1990, 1991 и т.д.)

__FILE__

Данныймакрос дает имя текущего обрабатываемого препроцессором исходного файла (в виде строкового лите-

рала). Когда препроцессор обрабатывает директиву #include

или #line, либопри завершении обработки включаемого файла,

данный макрос соответствующим образом меняет свое значение.

__LINE__

Данный макрос дает количество обработанных препроцессором к данному моменту строк текущего исходного файла. Обычно первая строка исходного файла определяется с номером 1, хотя на это может повлиять директива #line. Информацию о директиве #line см. на стр. 144 оригинала.

__MSDOS__

Данный макрос специфичен для Turbo C++. Он дает целочисленную константу 1 для всех случаев компиляции.

__OVERLAY__

Данный макрос специфичен для С++. Он предопределен равным 1, еслимодуль компилируетсяс опцией -Y (включена поддержка оверлейных структур). Если оверлейные структуры не поддерживаются, то данный макрос неопределен.

__PASCAL__

Данный макрос специфичен для С++. Он сообщает о том, чтобыл использован флаг -p. Макрос установлен равным целочисленной константе 1, если флаг -p использовался; в противном случае он неопределен.

__STDC__

Данный макрос определен равным константе 1, если компиляция выполняется при установленном флаге совместимости с ANSI (-Aили менюANSI Keywords Only...On); в противном случае макрос неопределен.

__TIME__

Данный макрос дает время начала обработки препроцессором текущего исходного файла (в виде строкового литерала).

Как и в случае макроса __DATE__, каждое включение __TIME__ будет содержать одно и то же значение, независимо от того, сколько времени продолжалась обработка файла. Он имеет формат hh:vv:ss, где hh это часы (от 00 до 23), mm это минуты (от 00 до 59), а ss это секунды (от 00 до 59).

__TURBOC__

Данный макрос специфичендля С++. Он дает номер текущей версии TurboC++ ввиде шестнадцатиричной константы. Например, версия 1.0 будет представлена в виде 0x0100.

Глава 2. Перекрестные ссылки по библиотеке исполняющей системы

Данная глава содержит обзор библиотечных подпрограмм Turbo C++ и включаемых файлов.

В данной главе

- объясняется, зачем вам могут понадобиться исходные коды библиотеки исполняющей системы Turbo C++

- перечисляются и описываются файлы заголовка

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

Turbo C++ поставляется с более чем 450 функциями и макросами, которые вы можете вызыватьиз своей программы для выполнения широкого круга задач, включая задачи ввода/вывода как высокого, так и низкого уровня, манипуляции с потокамии файлами, распределенияпамяти, преобразования данных, математических вычислений имногиедругие. Эти функции и макросы, называемые библиотечными подпрограммами, подробно описаны в Справочнике по библиотеке.

Подпрограммы Turbo C++содержатся в библиотечных файлах (Cx.LIB, CPx.LIB, MATHx.LIB и GRAPHICS.LIB). Поскольку TurboC++ поддерживает шесть различных моделей памяти, каждая модель, за исключением модели tiny, имеет свой собственный библиотечный файл и файл математических функций, в которых находятся версии этих подпрограмм специально для соответствующей модели памяти. (Модель tiny использует одни файлы с моделью small).

В С++ всегда нужно использовать прототипы. Дополнительную информацию о прототипах функций см. на стр.60 оригинала).

Turbo C++ является реализацией последнего стандарта ANSI C, который, помимо всего прочего, позволяет (и усиленно рекомендует) задавать прототипы функций для используемых в вашей программе на С подпрограмм.

Библиотечные подпрограммы Turbo C++ объявляются со своими прототипами в одном или более файлов заголовка.

Зачем нужен доступ к исходным кодам библиотеки исполняющей системы

Библиотека исполняющей системы Turbo C++ содержит свыше 450 функций, относящихся к широкому диапазону задач: управление IBM PC на нижнем уровне, интерфейс с DOS, ввод/вывод, управление обработкой, манипуляции со строками и памятью, математические вычисления, сортировка и поиск, и т.д. Существует несколько веских причин, по которым вам может понадобиться доступ к исходным кодам этих функций:

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

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

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

- Вам может понадобиться убрать ведущие символы подчеркивания в символических именах С. Это можно сделать только имея доступ к исходным кодам функций библиотеки исполняющей системы.

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

По всем этим причинам, а также по многимдругим, вам может понадобитьсядоступк исходным кодам библиотекиисполняющей системы Turbo C++. Поскольку фирма Borland придерживается принципа "открытой архитектуры", мы предоставляем возможность лицензированного доступа к исходным кодам библиотеки исполняющей системы Turbo C++. Все, что вам нужно для этого сделать,это заполнить бланк, поставляемый с пакетом Turbo C+ +, приложить платежный чек, и вам будутвысланы исходные коды библиотеки исполняющей системы Turbo C++.

Файлы заголовка Turbo C++

Файлы заголовка, определяемые стандартом ANCI C, соответственно обозначены на полях. Файлы заголовка С++ также обозначены на полях слева.

Файлы заголовка, называемые также включаемыми файлами, содержат объявления прототипов библиотечных функций. В них также находятся определения типов данных и символических имен констант библиотечных функций, а также глобальные переменные, определяемые TurboC++ и библиотечными функциями. Имена файлов заголовка и их содержимое в библиотеках Turbo C ++ следуют стандарту ANSI C.

alloc.h Объявляет функции управления памятью (распре-

деление и отмена распределения памяти и т.д.)

ANSI C assert.h Определяет отладочный макрос assert

C++ bcd.h Определяет класс С++ bcd и перегруженные опе-

рации для класса bcd и математические функции

для bcd

bios.h Объявляет различные функции, используемые при

вызове подпрограмм ROM BIOS IBM PC

C++ complex.h Объявляет комплексные математические функции С++

conio.h Объявляет различные функции, используемые при

вызове подпрограмм DOS ввода/вывода с консоли

ANSI C ctype.h Содержит информацию, используемую макросами символьной классификации и символьных преобразований (такими, как isalpha и toascii)

dir.h Содержит структуры, макросы и функции для

работы с директориями и путями доступа

dos.h Определяет различные константы и содержит объявления, необходимые при вызовах DOS и специальных вызовах 8086

ANSI C errno.h Определяет мнемонические константы кодов

ошибок

fcntl.h Определяет символические константы, исполь-

зуемые совместно с библиотечной подпрограммой

open

ANSI C float.h Содержит параметры подпрограмм обработки чисел с плавающей точкой.

C++ fstream.h Объявляет классы потоков С++, поддерживающие ввод-вывод в файлы

C++ generic.h Содержит макрос для объявлений родовых файлов

graphics.h Объявляет прототипы графических функций

io.h Содержит структуры и объявления подпрограмм

ввода/вывода низкого уровня

C++ iomanip.h Объявляет манипуляторы ввода/вывода потоков С++ и содержит макрос для создания параметри-

зованных манипуляторов

C++ iostream.h Объявляет подпрограммы (ввода/вывода) потоков базового (версии 2.0) С++

ANSI C limits.h Содержит параметры среды программирования, информацию об ограничениях времени компиляции, а также численные диапазоны интегральных типов

ANSI C locale.h Объявляет функции, содержащие информацию, специфичную для конкретной страны и языка

ANSI C math.h Объявляет прототипы математических функций; определяет макрос HUGE_VAL и объявляет структуру исключения, используемую подпрограммой matherr

mem.h Объявляет функции манипулирования памятью.

(Многие из них также определены в string.h)

process.h Содержит структуры и объявления для функций

spawn... и exec...

ANSI C setjmp.h Определяет тип jmp_buf, используемый функциями

longjmp и setjmp, и объявляет подпрограммы

longjmp и setjmp

share.h Определяет параметры, используемые в функциях,

работающих с разделением файла

ANSI C signal.h Определяет макросы, используемые для чтения списков аргументов функций, объявленных как принимающие переменное число аргументов (например, vprintf, vscanf и т.д.)

ANSI C stddef.h Определяет несколько общих типов данных и макросов

ANSI C stdio.h Определяет типы данных и макросы, необходимые для пакета стандартного ввода/вывода (Standard I/O Package), определенного Керниганом и Ритчи и расширенного в Системе UNIX V.

Определяет предопределенные потоки стандартного ввода/вывода stdin, stdout, stdprn и stderr, а также объявляет подпрограммы ввода/ вывода уровня потоков

C++ stdiostr.h Объявляет классы потоков С++ для использования в файловых структурах stdio FILE.

ANSI C stdlib.h Объявляет некоторые широко используемые подпрограммы: подпрограммы преобразования, подпрограммы поиска/сортировки и прочие

C++ stream.h Объявляет подпрограммы (ввода/вывода) потоков С++ (версии 1.2)

ANSI C string.h Объявляет несколько подпрограмм строковых манипуляций и манипуляций с памятью

C++ strstrea.h Объявляет классы потоков С++ для работы с байтовыми массивами в памяти

sys\stat.h Объявляет символические константы, используемые при открытии и создания файлов

sys\timeb.h Объявляет функцию time и структуру timeb,

возвращаемую time

sys\types.h Объявляет тип type_t, используемый функциями

времени

ANSI C time.h Определяет структуру, заполняемую подпрограммами преобразования времени asctime, localtime и gmtime, а также тип, используемый подпрограммами ctime, difftime, gmtime, localtime и stime; также содержит прототипы этих подпрограмм.

values.h Определяет важные константы, включая машинозависимые константы; обеспечивает совместимостью с системой UNIX V

Категории библиотечных подпрограмм

Библиотечные подпрограммы Turbo C++выполняют большое количество различныхзадач.В данном разделе перечислены все подпрограммы, а также включаемые файлы, в которых они объявлены, разбитые на несколько общих категорий по выполняемым задачам. Полную информацию по перечисленным ниже функциям см.в главе 1 "Библиотека исполняющей системы" Справочника по библиотеке.

Подпрограммы классификации ------------------------------

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

isalnum (ctype.h) isascil (ctype.h) isdigt (ctype.h)

isalpha (ctype.h) iscntrl (ctype.h) isgraph (ctype.h)

islower (ctype.h) ispunct (ctype.h) isupper (ctype.h)

isprint (ctype.h) isspace (ctype.h) isxdigit(ctype.h)

Подпрограммы преобразования -----------------------------

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

atof (stdlib.h) itoa (stdlib.h) _tolower (ctype.h)

atof (stdlib.h) itoa (stdlib.h) tolower (ctype.h)

atof (stdlib.h) strtod (stdlib.h) _tolower (ctype.h)

ocvt (stdlib.h) strtol (stdlib.h) tolower (ctype.h)

fcvt (stdlib.h) strtcul (stdlib.h) ultoa (stdlib.h)

gcft (stdlib.h) toascil (ctype.h)

Подпрограммы управления директориями-----------------------

Эти подпрограммы манипулируют директориями и именами пути доступа.

cndir(dir.h) fnsplit (dir.h) mkdir (dir.h)

findfirst (dir.h) getcurdir (dir.h) mktemp (dir.h)

findnext(dir.h) getcwd (dir.h) rmdir (dir.h)

fnmerge(dir.h) detdisk (dir.h) searchpath(dir.h)

setdisk (dir.h)

Диагностические подпрограммы-------------------------------

Эти подпрограммы реализуют встроенные средства поиска ошибки.

assert(assert.h)

matherr(math.h)

perror(errno.h)

Графические подпрограммы --------------------------------

Эти подпрограммы позволяют создавать экранные графические представления с текстовой частью.

arc (graphics.h) fillellipse (graphics.h)

bar (graphics.h) fillpoly (graphics.h)

bar3d (graphics.h) floofill (graphics.h)

circle (graphics.h) getarccoords (graphics.h)

cleardevice (graphics.h) getaspectratio (graphics.h)

clearviewport(graphics.h) getbkcolor (graphics.h)

closgraph (graphics.h) getcolor (graphics.h)

detectgraph (graphics.h) getdefaultpallette(graphics.h)

drawpoly (graphics.h) getdrivername (graphics.h)

ellipse (graphics.h) getfillpattern (graphics.h)

getfillsettings (graphics.h) outtext (graphics.h)

getgraphmode (graphics.h) outtextxy(graphics.h)

getimage (graphics.h) pieslice (graphics.h)

getfinesettings (graphics.h) pufimage (graphics.h)

getmaxcolor (graphics.h) pulpixel (graphics.h)

getmaxmode (graphics.h) rectangle(graphics.h)

getmaxx (graphics.h) registerbgidriver(graphics.h)

getmaxy (graphics.h) registerbgifont (graphics.h)

getmodename (graphics.h) restorecrtmode (graphics.h)

getmoderange (graphics.h) sector (graphics.h)

getpalette (graphics.h) settaffpalette (graphics.h)

getpixel (graphics.h) setaspectratio (graphics.h)

gettextsettings (graphics.h) setbkcolor (graphics.h)

getviewsettings (graphics.h) setcolor (graphics.h)

getx (graphics.h) setcursortype (conio.h)

gety (graphics.h) setfillpattern (graphics.h)

graphdefaults (graphics.h) setfillstyle (graphics.h)

grapherrormsg (graphics.h) setgraphbufsize (graphics.h)

_graphfreemem (graphics.h) setgraphmode (graphics.h)

_graphgetmem (graphics.h) setlinestyle (graphics.h)

graphresult (graphics.h) setpalette (graphics.h)

imagesize (graphics.h) setrgbpalette (graphics.h)

initgraph (graphics.h) settextjunistify (graphics.h)

installuserdriver(graphics.h)settexttyle (graphics.h)

installuserfont (graphics.h)setusercharsize (graphics.h)

line (graphics.h)setviewport (graphics.h)

linerel (graphics.h)setvisualpage (graphics.h)

lineto (graphics.h)setwritemode (graphics.h)

moverei (graphics.h)textheight (graphics.h)

moveto (graphics.h)textwidth (graphics.h)

Подпрограммы ввода/вывода --------------------------------

Эти подпрограммы реализуют средства ввода/вывода на уровне потоков и DOS.

access (io.h)creatnew (io.h)

cgets (conio.h)creattemp (io.h)

_chmod (io.h)cscanf (conio.h)

chmod (io.h)dup (io.h)

chsize (io.h)dup2 (io.h)

clearerr (stdio.h)eof (io.h)

_close (io.h)fclosse (stdio.h)

close (io.h)fcloseali (ctdio.h)

cprintf (conio.h)fdopen (stdio.h)

cputs (conio.h)foof (stdio.h)

_creat (io.h)ferror (stdio.h)

creat (io.h)fflush (stdio.h)

fgetc (stdio.h)printf (stdio.h)

fgetchar (stdio.h)putc (stdio.h)

fgetpos (stdio.h)putch (conio.h)

fgets (stdio.h)putchar (stdio.h)

fllelength (io.h)puts (stdio.h)

flleno (stdio.h)putw (stdio.h)

flushall (stdio.h)_read (io.h)

fopen (stdio.h)read (io.h)

fprintf (stdio.h)remove (stdio.h)

fputc (stdio.h)rename (stdio.h)

fputchar (stdio.h)rewind (stdio.h)

fputs (stdio.h)scanf (stdio.h)

fread (stdio.h)setbuf (stdiio.h)

freopen (stdio.h)setcursortype (conio.h)

fscanf (stdio.h)setftime (io.h)

fseek (stdio.h)setmode (io.h)

fsetpos (stdio.h)setvbuf (stdio.h)

fstat (sys\stat.h)sopen (io.h)

ftell (stdio.h)sprintf (stdio.h)

fwrite (stdio.h)sscanf (stdio.h)

getc (stdio.h)stat (sys\stat.h)

getch (conio.h) _strerror (string.h,stdio.h)

getchar (stdio.h) strerorr (stdio.h)

getche (conio.h) tell (io.h)

getftime (io.h) tmpfile (stdio.h)

getpaus (conio.h) tmpnam (stdio.h)

gets (stdio.h) ungetc (stdio.h)

getw (stdio.h) ungetch (conio.h)

iocti (io.h) unlock (io.h)

isatty (io.h) vfprintf (stdio.h)

kbhit (conio.h) vfscanf (stdio.h)

lock (io.h) vprintf (stdio.h)

iseek (io.h) vscanf (stdio.h)

_open (io.h) vsprintf (stdio.h)

open (io.h) vsscanf (io.h)

perror (stdio.h) _write (io.h)

Подпрограммы интерфейса --------------------------------- (DOS, 8086, BIOS)

Эти подпрограммы реализуют обращения к средствам DOS, BIOS и специфичным средствам данного компьютера.

absread (dos.h) bioskey (bios.h) dosexterr (dos.h)

abswrite (dos.h) bioskey (bios.h) enable (dos.h)

bdos (dos.h) biosprint (bios.h) FP_OFF (dos.h)

bdosptr (dos.h) biostime (bios.h) FP_SEG (dos.h)

bioscom (bios.h)country (dos.h) freemem (dos.h)

blosdisk (bios.h)ctrlbrk (dos.h) geninterrupt(dos.h)

biosequip(bios.h)disable (dos.h) getcbrk (dos.h)

getdfree (dos.h) int86 (dos.h) poke (dos.h)

getdta (dos.h) int86x (dos.h) pokeb (dos.h)

getfat (dos.h) intdos (dos.h) randbrd (dos.h)

getfatd (dos.h) intdosx (dos.h) randbwr (dos.h)

getpsp (dos.h) intr (dos.h) segread (dos.h)

getvect (dos.h) keer (dos.h) setcbrk (dos.h)

getverity(dos.h) MK_FP (dos.h) setdta (dos.h)

harderr (dos.h) outport (dos.h) setvect (dos.h)

hardresume(dos.h)outportb (dos.h) setverity (dos.h)

hardretn(dos.h)parsfnm (dos.h) sleep (dos.h)

inport(dos.h)peek (dos.h) unlink (dos.h)

inportb(dos.h)peekb (dos.h)

Подпрограммы манипуляции --------------------------------

Эти подпрограммы обрабатывают строкии блоки памяти: копирование, сравнение, преобразования и поиск.

memccpy(mem.h,string.h) stricmp(string.h)

memchr(mem.h,string.h) stricmpi(string.h)

memcmp(mem.h,string.h) sprien(string.h)

memcpy(mem.h,string.h) striwr(string.h)

memicmp(mem.h,string.h) stncat(string.h)

memmoye(mem.h,string.h) stncmp(string.h)

memset(mem.h,string.h) strncmpi(string.h)

movedata(mem.h,string.h) strncpy(string.h)

movmem(mem.h,string.h) strnicmp(string.h)

setmem(mem.h) strnset(string.h)

stpcpy(string.h) strpbrk(string.h)

strcat(string.h) strrchr(string.h)

strchr(string.h) strrev(string.h)

strcmp(string.h) strset(string.h)

strcoll(string.h) strspn(string.h)

strcpy(string.h) strstr(string.h)

strcspn(string.h) strtok(string.h)

strdup(string.h) strupr(string.h)

strerror(string.h) strxfrm(string.h)

Математические подпрограммы ----------------------------- Эти подпрограммы выполняют математические вычисления и

преобразования.

abs (complex.h,stdlib.h) atof(stdlib.h,math.h)

acos (complex.h,math.h) atoi(stdlib.h)

arg (complex.h) atol(stdlib.h)

asin (complex.h,math.h) bcd(std.h)

atan (complex.h,math.h) cabs(math.h)

atan2 (complex.h,math.h) ceil(math.h)

clear87 (float.h) ltoa(stdlib.h)

complex (complex.h) _matherr (math.h)

conj (complex.h) matherr(math.h)

_control(float.h) modf(math.h)

cos (complex.h,math.h) norm(complex.h)

cosh (complex.h,math.h) polar(complex.h)

div (math.h) poly(math.h)

ecvt (stdlib.h) pow(complex.h,math.h)

exp (math.h) pow10(math.h)

fabs (math.h) rand(stdlib.h)

fcvt (stdlib.h) random(stdlib.h)

floor (math.h) randomize(stdlib.h)

fmod (math.h) real(complex.h)

_fpreset(float.h) _rotl(stdlib.h)

frexp (math.h) _rotr(stdlib.h)

gcvt (stdlib.h) sin(complex.h,math.h)

hypot (math.h) sinh(complex.h,math.h)

imag (complex.h) sqrt(complex.h,math.h)

itoa (stdlib.h) srand(stdlib.h)

labs (stdlib.h) _status87(float.h)

ldexp (math.h) strtod(stdlib.h)

ldiv (math.h) strtol(stdlib.h)

log (complex.h,math.h) strtoul(stdlib.h)

log10 (complex.h,math.h) tan(complex.h,math.h)

_lrotl (stdlib.h) tanh(complex.h,math.h)

_lrotr (stdlib.h) ultoa(stdlib.h)

Подпрограммы управления памятью -------------------------

Эти подпрограммы обеспечивают динамическое распределение памяти для моделей данных small и large

allocmem (dos.h) farrealloc (alloc.h)

brk (alloc.h) free (alloc.h,

calloc (alloc.h) stdlib.h)

coreleft (alloc.h, heapcheck (alloc.h)

stdlib.h) heapcheckfree (alloc.h)

farcalloc (alloc.h) heapcheckknode (alloc.h)

farcoreleft (alloc.h) heapwalk (alloc.h)

farfree (alloc.h) malloc (alloc.h,

farheapcheck (alloc.h) stdlib.h)

farheapcheckfree(alloc.h) realloc (alloc.h,

farheapchecknode(alloc.h) stdlib.h)

farheapfllfree (alloc.h) sbrk (alloc.h)

farheapwalk (alloc.h) setblock (dos.h)

farmalloc (alloc.h)

Разные подпрограммы -------------------------------------

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

delay (dos.h) setjmp (setjmp.h)

localeconv (locale.h) setlocale (locale.h)

longjmp (setjmp.h) sound (dos.h)

nosound (dos.h)

Подпрограммы управления процессами ----------------------

Эти подпрограммы запускают и завершают выполнение одних процессов из других.

abort (process.h) execvp (process.h) spawnl (process.h)

execl (process.h) execvpe(process.h) spawnle (process.h)

execle (process.h) _exit (process.h) spawnlp (process.h)

execlp (process.h) exit (process.h) spawnlpe(process.h)

execlpe(process.h) getpid (process.h) spawnv(process.h)

execv (process.h) reise (signal.h)spawnve (process.h)

execve (process.h) signal (signal.h)spawnvp (process.h)

spawnvpe(process.h)

Стандартные подпрограммы --------------------------------

Эти подпрограммы являются стандартными.

abort (stdlib.h) exit (stdlib.h)malloc(stdlib.h)

abs (stdlib.h) fcvt (stdlib.h)putenv(stdlib.h)

atexit (stdlib.h) free (stdlib.h)qsort(stdlib.h)

atof (stdlib.h) gcvt (stdlib.h)rand(stdlib.h)

atol (stdlib.h) getenv (stdlib.h)realloc (stdlib.h)

atol (stdlib.h) itoa (stdlib.h)srand(stdlib.h)

bsearch(stdlib.h) labs (stdlib.h)stdtod(stdlib.h)

calloc (stdlib.h) lfind (stdlib.h)strtol(stdlib.h)

ecvt (stdlib.h) lsearch(stdlib.h)swab(stdlib.h)

_exit (stdlib.h) itoa (stdlib.h)system(stdlib.h)

Подпрограммы вывода на дисплей текстовых окон -------------

Эти подпрограммы выводят текст на экран.

clreol (conio.h) gotoxy (conio.h)

clrscr (conio.h) highvideo (conio.h)

delline (conio.h) insline (conio.h)

gettext (conio.h) lowvideo (conio.h)

gettextinvo(conio.h) movetext (conio.h)

normvideo (conio.h) textcolor (conio.h)

puttext (conio.h) textmode (conio.h)

necursortype (conio.h) wherex (conio.h)

textattr (conio.h) wherey (conio.h)

textbackground(conio.h) window (conio.h)

Подпрограммы времени и даты -----------------------------

Эти подпрограммы предназначены для преобразований и манипуляций временем и датой.

asctime (time.h) mktime (time.h)

ctime (time.h) setdate (dos.h)

difftime (time.h) settime (dos.h)

dostounix (dos.h) stime (time.h)

ftime (sys\timeb.h)strftime (time.h)

getdate (dos.h) time (time.h)

gettime (dos.h) tzset (time.h)

gmtime (time.h) unixtodos (dos.h)

locoltime (time.h)

Подпрограммы для обработки переменного списка аргументов

Эти подпрограммы используютсядля доступа к переменным спискам аргументов (например, vprintf и т.д.).

va_arg (stdarg.h)

va_end (stdarg.h)

va_stsrt (stdarg.h)

Глава 3 Потоки С++

Данная глава содержит краткий обзор ввода/вывода потоков С++. Ввод/вывод потоков в С++используется для преобразования типизированных объектов в читаемый текст, и обратно. Он позволяет определять функции ввода/вывода, которые затем автоматически используются применительно к соответствующим определенных пользователем типам. Последующие примеры находятся в Главе 5, "Основы С++" документа "Начало работы"; приводимая там же библиография предлагает несколько названий книг для углубленного изучения данного примера.

Новые потоки вместо старых

Turbo C++ поддерживает как старую библиотеку С++ stream, так и новую усовершенствованную библиотеку iostream С++ версии 2.0. Возможность работы с обеими версиями поможет вам, если у вас имеются программы, написанные по старым соглашениям, и вы желаете использовать Turbo C++ для перехода к более эффективным потокам ввода/вывода версии2.0. Мы настоятельно рекомендуем вампри создании новых программ пользоваться библиотекой iostream версии 2.0. Приводя некоторые материалы, необходимые дляперехода к потокам версии 2.0 (начиная со стр.184 оригинала), данная глава главным образом посвящается классам иправилам потоков iostream версии 2.0.

Использование потоков 2.0

Усовершенствованные потоки iostream версии 2.0, хотя и обеспечивают по большей части совместимость для старой версии С++, предлагают тем не менее новые возможности, связанные с использованием множественного наследования и прочими средствами, появившимися в С++ версии 2.0.

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

Концепция потоков С++ нацелена на решение нескольких проблем, решаемых стандартными библиотечнымифункциями ввода/ вывода С, такими какprintfи scanf. Последние, разумеется остаются доступными для программиста, работающего в С++, но улучшенная гибкость и элегантность потоков С++ уменьшают привлекательность функций библиотеки stdio.h. Классы, связанные с потоками С++, предлагают вам расширяемые библиотеки, позволяющие вам выполнять форматированный ввод/выводс контролемтипов какдля предопределенных, так и для определяемых пользователем типов данных спомощью перегруженных операцийи прочих объектно-ориентированных методов.

Для обращения к вводу/выводу потоком ваша программа должна включать файл iostream.h. Для некоторых функций потоков требуются и другие файлы заголовка. Например, для выполнения форматирования в оперативной памяти с использованием классов istrstream и ostrstream необходим файл strstream.h. Файл заголовка strstream.h включает также iostream.h. Если вам требуется класс fstream, включите файл fstream.h,такжевключающий iostream.h. И разумеется, можно включить одновременно и fstream.h, и strstream.h.

Что такое поток?

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

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

Библиотека iostream

Библиотека iostream имеет два параллельных класса: streambuf и ios. Оба они являются классами низкого уровня и каждый выполняет свой круг задач.

streambuf

Класс streambufобеспечивает общие правила буферизации и обработки потоков в тех случаях, когда не требуется значительного форматирования этих потоков. streambuf представляет собой удобный базовый класс, используемый другими частями библиотеки iostream, хотя он доступен также и для производных классов в ваших функциях и библиотеках. Большинство функций-компонентов (правил) streambuf являются встраиваемыми для обеспечения максимальной эффективности. Классы strstreambuf и filebuf являются производными от streambuf.

ios

Класс ios (и следовательно, производные от него классы) содержит указатель на streambuf.

ios имеет два производных класса: istream (для ввода) и ostream (для вывода). Другой класс, iostream, является производным классом сразуот istream иostream вследствие множественного наследования:

class ios;

class istream : virtual public ios;

class ostream : virtual public ios;

classiostream : public istream, public ostream;

Кроме того, существуеттри класса withassign, являющихся производными классами от istream, ostream и iostream:

class istream_withassign : public istream;

class ostream_withassign : public ostream;

class iostream_withassign : public iostream;

Классы потоков

- Класс ios содержит переменные состояния для интерфейса с streambuf и обработки ошибок.

- Класс istream поддерживает как форматированные, так и неформатированные преобразования потоков символов, извлекаемых из streambuf.

- Класс ostream поддерживает как форматированные, так и неформатированные преобразования потоков символов, помещаемых в streambuf.

- Класс iostream объединяет классы istream и ostream для двунаправленных операций, в которых один поток действует и как источник, и как приемник.

- Производные классы withassign обеспечивают четыре предопределенных "стандартных" потока: cin, cout, cerr и clog, описываемые в следующем разделе. Классы withassign добавляют к соответствующим базовым классам операции присвоения, следующим образом:

class istream_withassign : public istream (*

istream_withassign();

istream& operator=(istream&);

istream& operator=(streambuf*);

*)

и аналогично для ostream_withassign и

iostream_withassign.

Классом потока называется любой класс, производный от классов istream и ostream.

Четыре стандартных потока

Программы С++ начинаются с четырьмя предопределенными открытыми потоками, объявленными как объекты классов withassign в iostream.h следующим образом:

extern istream_withassign cin;

extern ostream_withassign cout;

extern ostream_withassign cerr;

extern ostream_withassign clog;

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

Четыре стандартных потока выполняют следующее:

cin Стандартный ввод (дескриптор файла 0)

(Соответствует stdin)

cout Стандартный вывод (дескриптор файла 1) (Соответствует stdout)

cerr Стандартный вывод ошибок (дескриптор файла 2). cerr буферизуется поблочно; очистка буфера происходит при каждой новой вставке

(Соответствует stderr)

clog Данный поток представляет собой полностью буферизуемую версию cerr.

Как и в С, вы можете переназначить эти стандартные имена на другие файлы или символьные буферы после загрузки программы.

Вывод

Вывод потока осуществляетсяоператором вставки,или помещения, <<. Для операций вывода перегружаетсястандартная операция сдвига влево <<. Ее левый операнд представляет собой объект типа класса ostream. Правый операнд может иметь любой тип, для которого определен вывод потоком (подробнее об этом говорится ниже). Вывод потоком определен для встроенных типов. Операция<<, перегруженнаядля типа type, называется вставкойэтого типа. Например,

cout << "Hello!\n";

записывает строку "Hello!" в cout (стандартный поток вывода, который обычно направлен на экран), после чего следует новая строка. Здесь << - это строка вставки типа char*.

Операция << обладает ассоциативностью слева и возвращает ссылку на объект ostream, для которого она вызывалась.Это позволяет организовать каскадные вставки:

void function_display(int i, double d)

(*

cout << "i=" << i << ", d=" << d << "\n";

*)

Это вызовет вывод чего-либо вроде:

i = 8, d = 2.34

на стандартное устройство вывода.

Отметим, что перегрузка не изменяет нормального приоритета выполнения операции <<, поэтому можно записать:

cout << "sum = " << x+y << "\n";

без круглых скобок. Однако, в случае

cout << (x&y) << "\n";

круглые скобки нужны.

Встроенные типы

Типы вставок, поддерживаемые непосредственно,это : char (signed и unsigned), short (signed иunsigned), int (signed и unsigned), long (signed и unsigned), char* (рассматриваемый как строка), float, double, long double и void*. Интегральные типы преобразовываются по правилам, по умолчанию действующим для printf (еслиэти правила не изменены путем установки различных флагов ios).Например, если заданы объявления int i; long l;, то следующие два оператора

cout << i << " " << l;

printf("%d %ld, i, l);

приведут к одному и тому же результату.

Аналогичным образом, типы сплавающей точкой преобразовываются правилам умолчания для printf с преобразованием %g. Итак, в случае объявления double d;, операторы

cout << d;

printf("%g", d);

дают один и тот же результат.

Вставка указателя (void*) также предопределена:

int i = 1;

cout << &i; // указатель выводится на дисплей в шестнадцати// ричном формате

Вставка char работает следующим образом:

char ch = 'A';

cout << ch; // на дисплей выводится А

Функции put и write

Для вывода двоичных данных или отдельного символа можно использовать функцию-компонент put, объявленнуюв ostream следующим образом:

ostream ostream::put (char ch);

При объявлении int ch='x'; следующие две строки эквивалентны:

cout.put(ch);

cout << (char)ch;

Функция-компонент writeпозволяет вывод больших по размеру объектов:

ostream& ostream::write(const signed char* ptr, int n);

ostream& ostream::write(const unsigned char* ptr, int n);

Функции write выводят nсимволов (включая любые входящие пустые символы) в двоичномформате. В отличие от строковой вставки, write не прекращает работу, встретив пустой символ. Например,

cout.write((char *)&x, sizeof(x))

пошлет непреобразованное представление х настандартное устройство вывода.

Существует тонкое различие между форматированной операцией << и неформатированнымифункциями putи write. Форматированная операция может вызвать очистку связанных потоков и иметь атрибут ширины поля.Неформатированные операции не обладают этими свойствами. Поэтому cout << 'a' и cout put ('a') могут давать разные результаты. Все флаги форматирования применимы к <<, но ни один из них не применим к put или write.

Форматирование вывода

Форматирование ввода и вывода определяется различными флагами состояний формата, перечисленными в классе ios. Эти состояния определяются битами числа типа long int следующим образом:

public:

enum (*

skipws = 0x0001, // пропуск пробельного символа на вводе

left = 0x0002, // вывод с левым выравниванием

right = 0x0004, // вывод с правым выравниванием

internal = 0x0008, // заполнитель после знака или

// указателя системы счисления

dec = 0x0010, // десятичное преобразование

oct = 0x0020, // восьмеричное преобразование

hex = 0x0040, // шестнадцатиричное преобразование

showbase = 0x0080, // показать на выходе указатель

// системы счисления

showpoint = 0x0100, // показать позицию десятичной точки

// (на выходе)

uppercase = 0x0200, // вывод шестнадцатиричных значений

// буквами верхнего регистра

showpos = 0x0400, // показать знак "+" для положительных

// чисел

scientific = 0x0800, // использовать запись чисел с плава-

// ющей точкой с выводом экспоненты Е

// например, 12345E2

fixed = 0x1000, // использовать запись чисел с плава-

// ющей точкой типа 123.45

unitbuf = 0x2000, // стирание всех потоков после вставки

stdio = 0x4000, // стирание stdout и stderr после

// вставки

*);

Разумеется, этифлаги наследуются производными классами ostream и istream. Приотсутствии специальных действий пользователяфлагиустанавливаются таким образом, чтобы выполнялось показанное впримерах выше форматирование по умолчанию. Существуют функции, позволяющие установке,проверку и сбросфлаговформата, как по отдельности, так и связанными группами. Некоторые флаги автоматически очищаются после каждого ввода/ вывода.

Основание системы счисления при преобразованиях

По умолчанию вставкаинтегральных типов выполняется в десятичной записи. Это можно изменить соответствующими установками флагов ios::dec, ios::oct и ios::hex (см. раздел "манипуляторы"). Есливсе эти флаги равнынулю (по умолчанию), то вставка выполняется в десятичном формате.

Ширина

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

int ios::width(int w); // устанавливает поле ширины в w

// и возвращает предыдущую ширину

int ios::width(); // возвращает текущую ширину --

// не внося никаких изменений

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

int i = 123;

int old_w = cout.width(6);

cout << i; // на выводе будет bbb123, где bbb =

// пробелы. Затем ширина устанавлива-

// ется равной 0

cout.width(old_w); // восстановление предыдущей ширины // поля

Отметим, что после каждой форматированной вставки ширина очищается в ноль, так что в

int i, j;

...

cout.width(4);

cout << i << " " << j;

i будет представлена минимум четырьмя символами, однако пробел в середине выражения и j будут представлены минимально необходимым числом символов.

Манипуляторы

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

cout << setw(4) << i << setw(6) << j;

эквивалентно более широкой записи

cout.width(4);

cout << i;

cout.width(6);

cout << j;

setw представляет собой параметризованный манипулятор, объявлениекоторого находится в iomanip.h. Прочие параметризованные манипуляторы, setbase, setfill, setprecision, setiosflags и resetiosflags, работают аналогичнымобразом (см таблицу 3.1). Для того, чтобы использовать эти манипуляторы, ваша программа должна включать iomanip.h. Вы можете писать свои собственные манипуляторы, без параметров:

ostream& dingy( ostream os)

(*

return os << "\a\a";

*)

...

cout << i << dingy << j;

Манипуляторы с параметрами более сложны и требуют включения iomanip.h.

Манипуляторы Таблица 3.1

Манипулятор Синтаксис Действие

dec outs<<dec Установка флага форма-

ins>>dec тирования с десятичными

преобразованиями

hex outs<<hex Установка флага форма-

ins>>hex тирования с шестнадцати-

ричными преобразованиями

oct outs<<oct Установка флага форма-

ins>>oct тирования с восьмеричными

преобразованиями

ws ins>>ws Извлечение пробельных

символов

endl outs<<endl Вставка символа новой

строки и очистка потока

ends outs<<ends Вставка оконечного

пустого символа в строку

flush outs<<flush Очистка ostream

setbase(int) outs<<setbase(n) Установка системы счис-

ления при преобразованиях с основой n (0, 8,

10 или 16). Ноль означает по умолчанию десятичную

систему при выводе и правила С для литералов це-

лых чисел при вводе.

resetiosflags(long) ins>>resetiosflags(l) Очистка форматных битов outs<<resetiosflags(l) в ins или outs, заданных аргументом l

setiosflags(long) ins>>setiosflags(l) Установка форматных битов outs<<setiosflags(l) в ins или outs, заданных аргументом l

setfill(int) ins>>setfill(n) Установка символа-за-

полнителяouts<<setfill(n) в n

setprecision(int) ins>>setprecision(n) Установка точности представления outs<<setprecision(n) чисел с плавающей точкой равной n разрядам

setw(int) ins>>setw(n) Установка ширины поля

outs<<setw(n) в значение n

Не-параметризованные манипуляторы dec, hex и oct (объявленные в ios.h) непринимают никаких аргументови просто изменяют основание системы счисления при преобразовании (и оставляютэто изменение в силе):

int i = 36;

cout << dec << i << " "

<< hex << i << "

<< oct << i << endl;

// вывод на дисплей 36 24 44

Манипулятор endl вставляет символ новой строки и очищает поток. Можно также в любой момент очистить ostream, записав

ostream << flush;

Заполнители и дополнение вправо и влево

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

По умолчанию символом-заполнителем является пробел. Изменить данное умолчание позволяет функция fill:

int i = 123;

cout.fill("*");

cout.width(6);

cout << i; // на дисплей будет выведено ***123

По умолчанию устанавливается выравнивание по правому краю (дополнение символами-заполнителями влево). Эти умолчания (а также прочие форматные флаги) можно изменять при помощи функций setf и unsetf:

int i = 56;

...

cout.width(6);

cout.fill('#');

cout.setf(ios::left,ios::adjustfield);

cout << i // на дисплей будет выведено 56####

Второй аргумент, ios::adjustfield, сообщает setf, какие биты должны быть установлены. Первый аргумент,ios::left, сообщает setf,в какие именно значения устанавливаютсяэти биты. Альтернативно можно использовать манипуляторы setfill, setiosflags иresetiosflags, которые позволяют модифицировать символ-заполнитель и направление дополненияпри форматировании (см. табл.3.1).

Вставки, определяемые пользователем

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

struct info (*

char *name;

double val;

char *units;

(*;

Вы можете перегрузить << следующим образом:

ostream& operator << (ostream& s, info& m)

(*

s << m.name << " " << m.val << " " << m.units;

*)

Операторы

info x;

...

// здесь инициализируется x

...

cout << x;

даст на выходе что-либо вроде "capacity 1.25 liters".

Ввод ----------------------------------------------

Ввод потоком аналогичен выводу, но использует перегруженную операцию сдвига вправо, >>, и называется операцией извлечения, или извлечением. Операция >> обеспечивает более компактную и читаемую альтернативу семейству функций scanf в stdio (она также лучше защищена от ошибок). Левый операнд >> представляет собой объект типа класса istream. Как и для вывода, правый операнд может быть любого типа, для которого определен вывод потоком.

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

cin >> x;

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

По умолчанию >> опускает пробельные символы (как определено функцией isspace в ctype.h), а затем считывает символы, соответствующие типуобъекта ввода. Пропуск пробельных символов управляется флагом ios::skipws в перечислимой переменной состояний формата (см. "Форматирование вывода" на стр.170 оригинала). Флаг skipws обычно устанавливает пропуск пробельных символов. Очистка этогофлага (например, припомощиsetf)выключает пропуск пробельных символов. Отметим также специальныйманипулятор "приемника", ws, который позволяет игнорировать пробельные символы (см. таблицу 3.1).

Изменение извлечений

Как и в случае <<, операция >> обладает свойством ассоциативности слева и возвращает левый операнд. Левый операнд является ссылкой на объект istream, для которого была вызвана данная операция. Это позволяет объединятьв одном операторе несколько операций ввода. Рассмотрим следующий пример:

int i;

double d;

cin >> i >> d;

Последняя строка вызывает пропуск пробельных символов; цифры, считываемые со стандартного устройства ввода(по умолчаниюэто ваша клавиатура), преобразуются затем во внутренний двоичный формат и записываются в переменную i; затемснова пропускаются пробельные символы, и наконец считываетсячисло с плавающей точкой, преобразуется и записывается в переменную d.

Извлечения для встроенных типов

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

Интегральные извлечения

Для типов short, int и long (signed и unsigned) действие операции >> по умолчанию заключаетсяв пропуске не-пробельныхсимволов и преобразовании интегрального значения путем чтения символов ввода до тех пор, пока не встретится символ, который не может являться допустимой частью представления данного типа. Формат распознаваемых интегральных значений тот же, что и для целочисленных констант С++, заисключением целочисленных суффиксов. (См. стр.11 оригинала).

Предупреждение

Если вы задали преобразования типа hex, dec или oct, то именно такиерезультаты выи получите. 0x10 становится0 в десятичном или восьмеричном представлении; 010 становится 10 в десятичном представлении и 16 в шестнадцатиричном.

Извлечения с плавающей точкой

Для типов float и double действие операции >> состоит в пропуске пробельных символов и преобразовании значения с плавающей точкой путем чтения вводимых символов до тех пор, пока не встретится символ, который не может являться частью представлениячисла с плавающей точкой. Формат распознаваемых значений с плавающей точкой тот же, что и для констант с плавающей точкой С++, за исключением суффиксов. (См. стр.16 оригинала).

Символьные извлечения

Для типа char (signed или unsigned) действие операции >> состоит в пропускепробельных символов и записи следующего (не-пробельного) символа. Если вам требуетсяпрочесть следующий символ, неважно, является ли он пробельным или нет, то можно использовать одну из функций-компонентов get:

char ch;

cin.get(ch); // ch устанавливается на следующий символ потока // даже если это пробельный символ

Функции get для ввода играют ту же роль, что функции putдля вывода. Следующий вариант get позволяет управлять числом извлекаемых символов, их размещением и оконечным символом:

istream& istream::get(char *buf, int max, int term='\n');

Эта функция считывает символы из входного потока в символьный массив buf до тех пор, пока не будет считано max-1 символов, либо пока не встретится символ, заданный term, в зависимости от того, что произойдет раньше. Завершающийпустойсимволдобавляется автоматически. По умолчаниютерминатором (который не требуется задавать) является символ новой строки ('\n'). Сам терминатор в массив buf не считывается и из istream не удаляется. Массив buf должен иметь размер как минимум max символов.

По аналогии с функцией-компонентом ostream write (см. стр.170 оригинала) можно прочитать "сырые" двоичные данные следующим образом:

cin.read ( (char*)&x, sizeof(x) );

Для типа char* (рассматриваемого как строка) действие операции >> состоит в пропуске пробельныхсимволов и записи следующих (не-пробельных) символов до тех пор, пока не встретится следующий пробельный символ. Затем добавляется завершающий нулевой (0) символ.Следует предъявлятьосторожность и избегать "переполнения" строки. Ширина по умолчанию, равная нулю (означает, что предельное значение не задано), может быть изменена при помощи setw следующим образом:

char array[SIZE];

...

// инициализация массива

...

cin.width(sizrof(array));

cin >> array // позволяет избежать переполнения

В случае любого вводавстроенных типов, если конец ввода встретится ранее первого не-пробельного символа, вмишеньbuf ничего записано не будет, а состояние istream будет установлено равным "отказу". Таким образом, если мишень была не инициализирована, то она и останется не инициализированной.

Функция возвращения

Функция-компонент

istream istream::putback(char c);

возвратит обратно в istream один символ c; если этот символ не может быть помещен обратно, то устанавливается состояние потока "отказ". Следующая простая подпрограмма выполняет считывание идентификатора С++ со стандартного устройства ввода:

void getident (char *s /* сюда помещается идентификатор */ )

(*

char c = 0; // защита от конца файла

cin >> c; // пропуск пробельных символов

if (isalpha(c) \!\! c == '_')

do (*

*s++ = c;

c = 0; // защита от конца файла

cin.get(c);

*) while (isalnum(c) \!\! c =='_');

*s = 0; // терминатор строки

if (c)

cin.putback(c); // один символ всегда лишний

*)

Ввод типов, определяемых пользователем

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

istream& operator >> (istream& s, info& m);

(*

s >> m.name >> m.val >> m.units;

return s;

*)

(В реальных прикладных программах, разумеется, вы можете добавить коды для проверки ошибок ввода). Для считывания строки ввода, такойкак "capacity 1.25 liters", можно использовать следующую запись:

cin >> m;

Инициализация потоков

Потоки cin, cout, cerr и clog инициализируются и открываются при загрузке программы и затем подключаются к соответствующим стандартным файлам. Инициализация (конструирование) потока означает ассоциирование его с буфером потока. Класс ostream имеет следующий конструктор:

ostream::ostream(streambuf*);

который инициализирует переменные состояния ios и ассоциирует буфер потока с объектом ostream. Конструктор istream работает аналогичным образом. В большинстве случаев вам не требуется специально рассматривать вопросами буферизации.

Библиотека iostream предлагает множество классов, производных от streambuf, ostream и istream, что дает широкий выбор методов создания потоков с различными источниками и приемниками, а также различными методами буферизации.

Следующие классы являются производными от класса streambuf:

filebuffilebuf поддерживает ввод/вывод через дескрипторы файлов. Функции-компонент класса поддерживают функции открытия, закрытия файлов и поиска.

stdiobufstdiobuf поддерживает ввод/вывод через структуры stdio FILE и предназначается исключительно для совместимости кодов С++ при их комбинировании с существующими программами С.

strstreambufstrstreambuf позволяет ввод и вывод символов из байтовых массивов в памяти. Два дополнительных класса, istrstream и ostrstream, обеспечивают ввод/ вывод с форматированием в памяти.

Специализированные классы для ввода/вывода в файл являются производными:

ifstream является производным от istream

ofstream является производным от ostream

fstream является производным от iostream

Эти триклассаподдерживают форматированный ввод/вывод в файлы при помощи буферов файлов (filebuf).

Простой ввод/вывод в файл

Класс ofstream наследует операции вставки отostream, а ifstream наследует операцииизвлечения отistream. Они также обеспечивают конструкторы и функции-компоненты для создании файлов и обработки ввода/вывода в этот файл. Следуетвключать fstream.h во все программы, где используются эти файлы. Рассмотрим следующий пример, в котором файл FILE_FROM копируется в FILE_TO:

#include fstream.h

...

char ch;

ifstream f1("file_from");

if (!f1) errmsg("Cannot open 'filr_from' for input");

ofstream f2("file_to");

if (!f2) errmsg("Cannot open 'filr_to' for output");

while ( f2 && f1.get(ch) ) f2.put(ch);

Ошибки, связанные с потоками, подробно обсуждаются на стр.181 оригинала.

Отметим, что если конструкторы ifstream или ofstream не могут открыть указанные файлы, то устанавливается соответствующее состояние ошибки потока.

Конструкторы позволяют объявить потокфайла без задания именованного файла. Затем вы можете ассоциировать данный поток файла с конкретным файлом:

ofstream ofile; // создание выходного потока файла

...

ofile.open("payroll"); // поток ofile ассоциируется с

// файлом payroll

// работа с некоторым паролем

ofile.close(); // payroll закрывается

ofile.open("employee"); // поток ofile можно использовать // повторно

По умолчанию файлы открываются в текстовом режиме.Это означает, что на вводе последовательность возврата каретки/перевода строки преобразуется в символ '\n'. На выводе символ '\n' преобразуется в последовательность возврат каретки/перевод строки. В двоичном режиме такие преобразования не выполняются.

Функциякомпонента ofstream::open объявляется следующим образом:

void open(char * name, int=ios::out, int prot=filуbuf:: openprot);

Аналогично, объявление ifstream::open имеет вид:

void open(char * name, int=ios::in, int

prot=filуbuf::openprot);

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

Бит режимаДействие

ios::appДобавление данных - запись всегда в конец файла ios::ateПоиск конца файла после первоначального открытия

ios::inОткрытие на ввод (подразумевается для ifstream) ios::outОткрытие на вывод (подразумевается для ofstream)

ios::truncУничтожение содержимого в случае, если файл существует (подразумевается, если ios::out задано, и ни ios::ate, ни ios::app не заданы)

ios::nocreateЕсли файл не существует, то open дает ошибку

ios::noreplace Если файл существует, open для файлов вывода дает ошибку, если не установлены ate или app

-----------------------------------------------------------

Мнемоника режима берется из перечислимого значения open _mode в ios:

class ios (*

public:

enum open_mode (* in, out, app, ate, nocreate, noreplace *);

*);

Оператор

ofstream ofile("data",ios::app\!ios::nocreate);

попытается открыть файл DATA на вывод в режиме append; если файл не существует, это приведет к неудаче. Информация об этой неудаче будет обозначена состоянием ошибки ofile. В случае удачного завершения поток ofile будет добавлен к файлу DATA. Класс fstream (производный от двух классов ifstream и ofsrtream) может использоваться для создания файлов, одновременно позволяющих и ввод, и вывод:

fstream inout("data:,ios::in\!ios::out);

inout << i;

...

inout >> j;

Для определения текущей позиции "get" или текущей позиции "put" файла можно воспользоваться функциями tellg и tellp; они определяют положение в потоке, гдебудет выполнена следующая операция вывода или ввода:

streampos cgp = inout.tellg(); // cgp - это текущая позиция get

где streampos это typedef в fstream.h. Функции-компоненты seekg и seekp могут сбрасывать значения текущей позиции get и put:

inout.seekg(cp); // установка в cp текущей позиции "put"

Варианты seekp и seekg позволяют получить искомые позиции в относительных смещениях:

inout.seekg(5,ios::beg); // перемещение cp на 5 байт от начала

inout.seekg(5,ios::cur); // перемещение cp на 5 байт вперед

inout.seekp(5,ios::end); // перемещение cp на 5 байт до конца

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

Состояния ошибки потока ввода/вывода

Каждый поток имеет связанное с ним состояние ошибки, т. е. набор битов ошибок, объявленный как перечислимое значение io_state в классе ios:

class ios (*

public:

...

// биты состояния потока

enum io_state (*

goodbit = 0x00,

eofbit = 0x01,

failbit = 0x02,

badbit = 0x04,

hardfail = 0x10

*);

...

*);

Отметим,что goodbit в действительности не является витом, а представляет собой нулевое значение, указывающее на то,что никакие биты ошибки не устанавливались.

Ошибки ввода/вывода потоком устанавливает соответствующий бит(ы), как указано в табл.3.2.

Биты ошибок ios Таблица 3.2

Бит состояния Его смысл

goodbit Если этот бит не установлен, то все в порядке.

eofbit "Конец файла": устанавливается, если istream не

имеет больше битов для извлечения. Последующие

попытки выполнить извлечение игнорируются.

failbit Устанавливается, если последняя операции ввода/

вывода (извлечение или преобразование) окончилась

неудачей. После сброса данного бита ошибки поток

готов к последующему использованию.

badbit Устанавливается, если последняя попытка ввода/

вывода являлась недопустимой. Поток может быть использован (не всегда) после сброса условия ошибки.

hardfail Устанавливается, если для данного потока встретилось невосстановимое состояние ошибки.

-----------------------------------------------------------

После того, как поток получил состояние ошибки, все попытки вставки или извлечения из данного потока будут игнорироваться до тех пор, пока не будет исправлено условие, вызвавшее состояние ошибки, а бит(ы) ошибки очищен(ы) (при помощи, например, функции компонента ios::clear(i). Функциякомпонент ios::clear(i) фактически устанавливает биты ошибки в соответствии с целочисленным аргументом i, так что ios::clear(0) очищает все биты ошибки, за исключением hardfail, который таким образом очищен быть не может.

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

Функции-компоненты для обработки текущего состояния потокаТаблица 3.3

Функция компонент Действие

int rdstate(); Возвращает текущее состояние ошибки

void clear(int i=0); Устанавливает биты ошибки в i. Например, код str.clear(ios::failbit\!str.rdstate());

устанавливает failbit потока str без разрушения прочих битов

int good(); Возвращает не-нулевое значение, если биты

ошибки не устанавливались; в противном случае

возвращает ноль

int eof(); Возвращает не-нулевое значение, если

установлен бит eofbit istream; в противном

случае возвращает ноль.

int fail(); Возвращает не-нулевое значение, если был

установлен один из битов failbit, badbit или

hardfail; в противном случае возвращает ноль.

int bad(); Возвращает не-нулевое значение, если был

установлен один из битов badbit или

hardfail; в противном случае возвращает ноль.

Вы можете также контролировать наличие ошибок, проверяя поток, как если бы он был логическим выражением:

if (cin >> x) return; // ввод в порядке

... // здесь восстановление в случае ошибки

if (!cout) errmsg("Ошибка вывода!");

Эти примеры подчеркивают элегантность С++. Класс ios имеет следующие объявления функции operator:

int operator! ();

operator void* ();

Операцияvoid*() определена как "преобразующая" поток в указатель, который будет равен 0 (ложь), если установлены failbit, badbit или hardfail, и не-нулевому значению в противном случае. (Отметим, что возвращаемый указатель должен использоваться только в логическихпроверках; другого практического применения он не имеет). Перегруженная операция "не" (!) определена как возвращающая не-нулевое значение (истина), если установлены биты ошибки потока failbit, badbit или hardfail; в противном случае она возвращает ноль (ложь).

Использование потоков прошлых версий

Хотя библиотеки stream версий 1.x и iostreamверсии2.0 разделяют многие имена классов и функцийи предлагают многие аналогичные средства, их структуры внекоторых важных областях несколько отличны друг отдруга.Turbo C++, следовательно, реализует два потока с разными библиотеками ифайлами заголовка. Для работы целиком со старыми кодами, использующими потоки, вы должны включить файл stream.h, избегать включения iostream.h и выполнять компоновку со старой библиотекой stream. Дополнительная информация о потоках версии 1.х находится в файле OLDSTR.DOC. Мы такжерекомендуем вам ознакомиться с объявлениями и комментариями в stream.h.

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

Рекомендации по переходу к потокам версии 2.0

Ключевое различие между старыми и новыми классами потоков состоит в том, чтокомпоненты public старого класса streambuf теперь, в новом классе streambuf, объявлены как protected. Если ваш старый код с потоками выполняет к таким компонентам прямые ссылки, либо если у вас имеются производные от streambuf классы, определенныена основаниитаких компонентов, то вы должны пересмотреть такие программы, прежде чем они пойдут сбиблиотекой iostream. Другой аспект, способныйповлиять на совместимость, состоит в том, что старый streambufпрямоподдерживал использование символьных массивов для форматирования в оперативной памяти. В случаеiostream эта поддержка предполагается в производном классе strstreambuf, объявляемом в strstream.h.

Старые конструкторы потока, запускающие буферы файлов, например

istream instream(дескриптор_файла)4

должны быть заменены на

ifstream instream(дескриптор_файла);

в программах с использованием iostream.

Старые и новыеклассы потоков по-разному взаимодействуют с stdio. Например, stream.h включает stdio.h, а старые istream и ostream поддерживаютуказатели на структуру stdio FILE. В случае iostream stdio поддерживается через специализированный класс stdiostream, объявленный в stdiostream.h.

В старой библиотеке stream предопределенные потоки cin, cout и cerr связаны непосредственно с файлами структуры FILE в stdio: stdin, stdout и stderr. Вслучаеiostream они подключаются к дескрипторам файлов и используют различные стратегии буферизации. Для того, чтобы избежать проблем с буферизацией при смешанном использовании кодов с stdout и cout, можно записать:

ios::sync_with_stdio();

где выполняется подключение предопределенных потоков к файлам stdio в режиме без буферизации. Отметим, однако, что такой способ значительно замедляет работу cin, cout и cerr, соответственно.

Старая библиотека stream позволяла непосредственно присваивать один поток другому; например,

ostream outs; outs = cout; // только для старых потоков

В случае iostream допустимо присвоение только потоку в левой части выражения присвоения; другими словами, типа istream_withassign или ostream_withassign. Если ваша программа содержит такие присвоения, то их можно либо переписать с использованием ссылок или указателей, либо изменить объявления:

ostream_withassign outs = cout; // только для новых потоков outs << i; // iostream

- 171 -

Глава 4 Модели памяти, операции с плавающей точкой и оверлеи

Данная глава рассматривает три основных вопроса:

- Модели памяти, от tiny до huge. Мы расскажем вам, что они из себя представляют, как выбрать модель памяти и зачем может понадобиться (или почему может не понадобиться) использовать ту или иную конкретную модель памяти.

- Опции операций с плавающей точкой. Как и когда использовать зти опции.

- Оверлеи. Как они работают, и как их использовать.

Модели памяти

Краткий обзор каждой модели памяти см. на стр.194 оригинала.

Turbo C++ предоставляетшесть моделейпамяти, каждая из которых соответствует определенномутипу программы и размеру кодов. Каждая модель памяти по-своему работает с памятью. Почему необходимо разбираться в моделях памяти? Для ответа на этот вопрос следует рассмотреть систему компьютера, с которой вы работаете. В основе блока центрального процессора системы лежит микропроцессор, принадлежащий к семейству микропроцессоров Intel iAPx86; это могут быть процессоры 8088 или 80286, на также и 8086, 80186, 80386или 80486. Пока будем обозначать процессор как 8086. Регистры 8086

Процессор 8086 содержит некоторый показанныйниже набор регистров. Существует, помимо того, еще один регистр - IP (указатель команд) - однако TurboC++ не имеетвозможности непосредственного к нему доступа, и потому он не показан.

Регистры общего назначения

-------------

AX \! AH \! AL

------------------

\! сумматор (матем.операции

BX \! BH \! BL

\! базовый регистр (индексация)

CX \! CH \! CL

\! счетчик (индексация)

DX \! DH \! DL -------------

\! данные (содердит данные)

------------------

Адресные сегментные

регистры

CS \! \! указатель кодового сегмента

DS \! \! указатель сегмента данных

SS \! \! указатель сегмента стека

ES \! \! указатель вспомог. сегмента

Регистры специального назначения

SP

\!

\! указатель стека

BP

\!

\! указатель базы

SI

\!

\! исходный индекс

DI

\!

-------

\! индекс назначения

------------------------

Рис.4.1

Регистры 8086

Регистры общего назначения

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

- Некоторые математические операции могут быть выполнены только с помощью АХ.

- ВХ можно использовать как индексный регистр.

- СХ используется командой LOOP и некоторыми строковыми командами.

-DX неявно используется некоторыми математическими операциями.

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

Сегментные регистры

Сегментные регистры содержат начальные адреса каждого из четырех сегментов. Как будет описано в следующем разделе, 16-битовое значение в сегментном регисире сдвигается влево на 4 бита (т.е. умножается на 16), в результате чего получается 20-битовый адрес данного сегмента.

Регистры специального назначения

8086 имеет несколько регистров специального назначения:

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

- Регистр SP указывает на текущую вершину стека и часто содержит смещение для регистра стека.

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

Функции С используют в качестве базового адреса аргументов и динамических локальных переменных регистр - указательбазы (ВР). Параметры имеют положительные смещения относительно ВР, зависящие от модели памяти. ВР всегда указываетна предыдущеесохраненное значение ВР.Функции, не имеющие аргументов, не используют и не сохраняют ВР, если опция StandartStack Frame ("Стандартный стековый фрейм") находится в состоянии Off.

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

Регистр флагов

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

виртуальный режим 8086

\! возобновление

\! \! вложенная задача

\! \! \! уровень защищенного

\! \! \! ввода/вывода

\! \! \! \! переполнение

\! \! \! \! \! признак

\! \! \! \! \! направления

\! \! \! \! \! \! прерывание

\! \! \! \! \! \! разрешено

\! \! \! \! \! \! \! внутреннее

\! \! \! \! \! \! \! прерывание

\! \! \! \! \! \! \! \! знак

\! \! \! \! \! \! \! \! \! ноль

\! \! \! \! \! \! \! \! \! \!перенос с

\! \! \! \! \! \! \! \! \! \!заемом

\! \! \! \! \! \! \! \! \! \!\! четность

\! \! \! \! \! \! \! \! \! \!\! \! перенос

\! \! \! \! \! \! \! \! \! \!\! \!\!

31 23 \! \!15\! \! \! \! \!\! 7 \!\! \!0

\! \! \! \! \! \! \! \! \! \! \! \! \! \! \!V\!R\! \!N\!IOP\!O\!D\!I\!T\!S\!Z\! \!A\! \!P\! \!C\!

-----------------------------------------------------------

\_____________________________/ \_____/ \_________________/

только 80386 80286 все процессоры 80х86

80386

Рис.4.2 Регистр флагов 8086

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

Прочие флаги контролируют режимы работы 8086. Флаг направления управляет направлением смещения строковых команд, а флаг прерываний управляет тем, разрешено ливнешним аппаратным устройствам, таким как клавиатура или модем, временно приостанавливать выполнение текущего кода для обслуживания возникающих у нихпотребностей. Флаг внутренних прерываний используется только программным обеспечением, предназначеннымдля отладки другого программного обеспечения.

Обычно регистр флагов не считываетсяи не модифицируется непосредственно. Обычно обращения к этому региструвыполняются посредством специальных ассемблерных команд (таких как CLD, STI и CMC), а такжепри помощи арифметических илогических команд, модифицирующих конкретные флаги. Подобным же образом, содержимое конкретных битов регистра флагов влияет на работу таких команд, как JZ, RCRи MOVSB. Регистр флагов фактическиникогда не используется как адрес памяти, а содержит данные о состоянии и управлении 8086.

Сегментация памяти

Микропроцессор Intel 8086 имеет сегментированную архитектуру памяти. Он имеет общий объем памяти 1 Мб, но позволяет одновременно адресовать только 64 Кб памяти. Такой участок памяти называется сегментом; отсюда и название "сегментированная архитектура памяти".

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

- 8086 имеет четыре 16-битовых сегментных регистра (один на каждый сегмент) с именами CS, DS, SS и ES; они указывают на кодовый сегмент, сенгмент данных, стека и вспомогательный сегмент, соответственно.

- Сегмент может располагаться в произвольном адресе памяти - практически везде. По причинам, которые станут вам ясны по мере ознакомления с материалом, сегмент должен располагаться в памяти, начиная с адреса, кратного 16 (десятичное).

Вычисление адреса

Полный адрес в8086 состоит из двух 16-битовых значений: адреса сегмента и смещения. Предположим, что адрес сегмента данных - т.е. значение в регистре DS -- равен 2F84 (шестнадцатиричное) и вы желаете вычислить фактический адрес некоторого элемента данных, который имеет значение 0532 (основание

16) от начала сегмента данных; как это сделать?

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

Полученное 20-битовое значениеи есть фактический адрес данных, как показано ниже:

регистр DS (после сдвига):0010 1111 1000 0100 0000 = 2F840 смещение: 0000 0101 0011 0010 = 00532

--------------------------------------------------------

Адрес:0010 1111 1101 0111 0010 = 2FD72

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

Начальный адрес сегмента всегда является20-битовым числом, но сегментный регистр имеет всего 16 битов - поэтому младшие 4 бита всегда предполагаются равными нулю. Это означает - как было уже сказано - что начало сегмента можетнаходиться только в адресах памяти, кратных 16, т.е. адресах, в которых последние 4 бита (или один шестнадцатиричный разряд) равен нулю. Поэтому если регистр DS содержит значение 2F84, тофактически сегмент данных начинается в адресе 2F840.

Стандартная запись адреса имеет форму сегмент:смещение; например, предыдущий адрес можно записать как 2F84:0532. Отметим, что поскольку смещения могут перекрываться, данная пара сегмент:смещение неявляется уникальной; следующие адреса относятся к одной и той же точке памяти:

0000:0123

0002:0103

0008:00A3

0010:0023

0012:0003

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

Указатели

Какое отношение имеют указатели к моделям памяти и Turbo C++? Самое непосредственное. Тип выбранной вами модели памяти определяет тип по умолчанию указателей, используемых для кода и данных (хотявы можете явно объявить указатель или функцию как имеющие тот или иной конкретный тип, независимо от текущей модели памяти). Указатели бывают четырех разновидностей: near (16 битов), far (32 бита), huge (также 32 бита) и segment (16 битов).

Ближние указатели (near)

16-битовый (near) указатель для вычисления полного адреса связывается с одним из сегментных регистров; например, указатель функции складывает свое 16-битовоезначение со сдвинутым влево содержимым регистра кодового сегмента (CS). Аналогичным образом, ближний указатель данных содержит смещение в сегменте данных, адресуемом регистром сегмента данных (DS). С ближнимиуказателями легкоманипулировать, поскольку все арифметические операции с ним (например, сложение) можно выполнять безотносительно к сегменту.

Дальние указатели (far)

Дальний (32-битовый) указатель содержит не только смещение относительно регистра, но также и (в остальных 16 битах) адрес сегмента, который затем должен быть сдвинут влево и сложен со значением смещения. Использование дальних указателей позволяет иметьв программе несколько кодовых сегментов; это, в свою очередь, позволяет программе превышать 64К. Можно также адресовать более 64К данных.

При использовании дальних указателей для адресации данных вам следует учитывать некоторые потенциальные проблемы, которые могут возникать при манипулировании такими указателями. Какобъяснялось в разделе, посвященном вычислениямадреса, может существовать множество пар типа сегмент:смещение, адресующих одну и ту же точку памяти. Например, дальние указатели 0000:0120, 0010Ж0020 и 0012:0000 разрешаются к одному и тому же 2-битовому адресу. Однако, если у вас были бы три переменных типа дальнего указателя - a,b и c, содержащих соответственно три указанных значения, то следующие выражения все давали бы значение "ложь":

if (a == b) . . .

if (b == c) . . .

if (a == c) . . .

Аналогичная проблема возникает, когда вам требуется сравнивать дальние указатели при помощи операций >, >=, < и <=. В этих случаях в сравнении участвует только смещение (как unsigned); при указанных выше значениях a, b и cследующие выражения дадут значения "истина":

if (a > b) . . .

if (b > c) . . .

if (a > c) . . .

Операции равенства (==) и неравенства (!=) используют 32-битовые значения как unsigned long (а не в виде полного адреса памяти). Операции сравнения(<=, >=, < и >) используют только смещение.

Операции== и != требуют все 32 бита, что позволяет компьютеру выполнять сравнение с пустым (NULL) указателем (0000:0000). Если дляпроверки равенства использовалось только значение смещения, то любой указатель со смещением 0000 будет равен пустому указателю, что явно несовпадает с тем, что вы хотели получить.

Важное замечание

При сложении некоторого значения сдальним указателем изменяется только смещение. Если слагаемое настолько велико, что сумма превышает FFFF (максимально возможная для смещения величина), то указатель перейдет снова к началу сегмента. Например, если сложить 1 и 5031:FFFF, то результат будет равен 5031:0000 (а не 6031:0000). Подобным же образом, при вычитании 1 из 5031:0000 получится 5031:FFFF (а не 5030:000F).

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

Указатели huge

Указатели huge также имеют размер 32 бита. как и указатели far, они содержат одновременно адрес сегмента и смещение. Однако, в отличие от дальних указателей, они нормализованы, что позволяет избежать проблем, связанных с дальними указателями.

Что такое нормализованный указатель? Это 32-битовый указатель, который содержитв своем адресе сегмента максимально возможное там значение. Поскольку сегмент может начинаться через каждые 16 байт (10 при основании 16), это означает, что величина смещения будет равна числу от 0 до 15 (от 0 до F с основанием 16).

Для нормализации указателя он преобразуется к20-битовому адресу, после чего правые 4 бита берутся в качестве смещения, а левые 16 битов - как адрес сегмента. Например, указатель 2F84:0532 можно сначала преобразовать к абсолютному адресу 2FD72, после чего получить нормализованный указатель2FD7:0002. Приведемеще ннесколько указателей с нормализованными значениями:

0000:01230012:0003

0040:00560045:0006

500D:9407594D:0007

7418:D03F811B:000F

Существует три причины, заставляющие всегда хранить указатель huge в нормализованном виде:

1. Поскольку в таком случае любому заданному адресу памяти соответствует только один возможный адрес в виде сегмент:смещение типа huge. Это означает, что для указателей huge операции == и != всегда будут возвращать правильное значение.

2. Кроме того, операции >, >=, < и <= работают с полным 32-битовым значением указателя huge. Нормализация гарантирует в данном случае корректность результата.

3. И наконец, вследствие нормализации смещение в указателе huge выполняет автоматический переход через 16 но вотличие от дальних указателей, переход затрагивает и сегмент. Например, при инкременте 811B:000Fрезультатбудет равен 811C: 0000; аналогичным образом, при декременте 800C:0000 получится 811B:000F. Эта особенность указателей huge позволяет манипулировать соструктурами данных сразмером более 64К. Гарантируется, например, что если у вас имеется массив структур типа huge, превышающий 64К, индексация этого массива и выбор поля структуры всегда будут выполняться правильно, независимо от размера структуры.

Использование указателей huge имеет свою цену: увеличение времени обработки. Арифметические операции с указателями huge выполняются при помощи обращений к специальным подпрограммам. Вследствие этого арифметические вычисления занимаютсущественно больше времени по сравнению с вычислениями для указателей far или near.

Шесть моделей памяти

Turbo C++ работает с шестью моделями памяти: tiny, small, medium, compact, large и huge. выбор модели памяти определяется требованиями вашей программы.Ниже приводятся кратк