---

Разделы На главную История денег и экономики История экономических знаний Формы безналичных денег Международные финансы Экономические концепции Экономические теории Экономика в реальной жизни Экономический анализ и интеграция Макроэкономика Экономика и социальное общество Социальная экономика Социология Кризисная экономика Инфляция в экономике Экономика зарубежных стран Иностранные деньги Государственное регулирование Бюджетная система Политическая экономия Политология Законы денег Налогообложение Аудит Банкротство Теория рынка Конкуренция Международная торговля Товарная биржа Нефть и газ на бирже Логистика Банки - услуги и операции Банки в России Банковский кредит Недвижимость Ипотека в банке Инвестирование Стратегии инвестирования Инвестиционные фонды Ценные бумаги Акции Вексель Облигации Опционы Фьючерсы Биржевая торговля Биржа Forex Фондовый рынок Фондовый рынок России Волны Эллиотта Теория фракталов Торговая теория Ганна Фибоначчи на бирже Графический анализ на бирже Паттерны Биржевой анализ "Крестики-нолики" Японские свечи Технический анализ Математика на бирже Фундаментальный анализ Биржевая торговля Стратегии торговли Механические торговые системы Программирование МТС Управление торговым капиталом Управление портфелем Управление риском Страхование Профессия трейдер Практический трейдинг Технологии инфосистем Информационный рынок Безопасность информации Криптология и криптография Реклама PR - Public Relations Маркетинг Финансовая система Начало бизнеса Предпринимательство Малый бизнес Микроэкономика Торговля Ценообразование Работа в Интернете Сайты, софт, дизайн Управление качеством Управление предприятием Производство продукции Стратегический менеджмент Учебники по менеджменту Системы и организации Теория систем Планирование Статистика финансов Управление персоналом Трудовые отношения Бухгалтерия «1С:Бухгалтерия» Управленческий учет Делопроизводство и офис Автоматизация делопроизводства Рынок труда Карьера Менеджер Лидерство и бизнес карьера Лидерство и карьера Общение и переговоры Общение в бизнесе Бизнес переговоры Инновации в моделировании Экономическое моделирование Нейронные сети Нейролингвистика Логика нейросетей Программирование Пакет Excel Технологии программирования Языки программирования Практическая психология Психологические тренинги Психология в медицине Возрастная психология Ваши скрытые резервы Здоровье и долголетие Работа с эмоциями Пикап Управление временем Гипнотерапия Подсознание Трансовые техники Магия Здоровье советы Спорт для здоровья Йога Религии Эзотерика Мистицизм

---

Сообщения ввода

WM_CHAR	WM_MENUSELECT
WM_CHARTOITEM	WM_PARENTNOTIFY
WM_COMMAND	WM_SYSCHAR
WM_DEADCHAR	WM_SYSDEADCHAR
WM_KEYDOWN	WM_SYSKEYDOWN
WM_KEYLAST	WM_SYSKEYUP
WM_KEYUP	WM_TIMER
WM_MENUCHAR	WM_VKEYTOITM

Сообщения Windows

WM_ACTIVATE	WM_KILLFOCUS
WM_ACTIVATEAPP	WM_MOVE
WM_CANCELMODE	WM_PAINT
WM_CLOSE	WM_PAINTICON
WM_CREATE	WM_Q

Соответствие цветов интерфейса системным цветам

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

собственные системные цвета пользователя. В первом параметре этой

функции с помощью операции OR комбинируются из 5 флагов:

Флаг Замена Заменяется на

TDib::MapText	TColor::Black	COLOR_BTNTEXT
TDib::MapFace	TColor::LtGray	COLOR_BTNFACE
TDib::MapFace	TColor::Gray	COLOR_BTNSHADOW
TDib::MapFace	TColor::White	COLOR_BTNHIGHLIGHT
TDib::MapFrame	TColor::LtMagenta	COLOR_WINDOWFRAME

Второй параметр, если он задается, приводит к замене TColor::LtYellow на bkColor. Так как эта функция ищет и заменяет записи таблицы TColor, ее полезно использовать с DIB только в режиме RGB. Поскольку она заменяет отдельные цвета, вы должны проектировать свой интерфейс с использованием стандартный цветовой

схемы.

Сопроцессор

Си работает с двумя числовыми типами: целыми (int, short,

long и т.д.) и с плавающей точкой (float double и long double).

Процессор вашего компьютера легко справляется с обработкой чисел

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

Семейство процессоров iAPx86 имеет сопутствующее ему семейство математических сопроцессоров - 8087, 80287 и 80387. Мы будем

обозначать все семейство математических сопроцессоров 80x87 термином "сопроцессор". (В случае процессора 80487 вы имеете математический сопроцессор уже встроенным в основной.)

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

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

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

80х87 по специальным шинам интерфейса.

Совместная работа документов и отображаемых элементов

В данном разделе описываются основные принципы модели

Doc/View. Эта модель освобождает программиста и пользователя от

необходимости думать от типах данных и о том, как они представляются на экране. Doc/View связывает типы файлов данных с классом

документа и классом просмотра. Администратор документов поддерживает список ассоциаций между классами документа и классами просмотра. Каждая ассоциация называется шаблоном документа (не путайте его с шаблонами С++).

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

Когда пользователь открывает документ (существующий или создавая новый документ), он выводится с помощью соответствующего

(ассоциированного с ним) класса отображаемого элемента. Класс

отображаемого элемента управляет выводом данных на экран и тем,

как пользователь взаимодействует с данными на экране. Фактически,

отображаемый элемент формирует интерфейс между окном на экране и

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

Совместное использование Style Sheet

Если вы создаете для проекта набор Style Sheet, а затем выбираете Project New project, то новый проект наследует Style Sheet (а также инструментальные средства и параметры) из старого

проекта. Однако, если вы закроете проект или перезапустите IDE,

то вам придется заново открыть проект со Style Sheet, а затем

создать новый проект, наследующий Style Sheet.

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

информацию об используемых в проекте наборах Style Sheet и Tools.

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

При открытии файла проекта администратор проекта отрывает

файл .PDL с тем же именем, что и имя файла .IDE. Чтобы совместно

использовать в проектах Style Sheet, сделайте следующее:

Откройте файл .PDL, содержащий Style Sheet, используя

обычный текстовый редактор.

Найдите имя Style Sheet и скопируйте текст, заключенный в

фигурные скобки (можно сделать несколько копий).

Откройте файл .PDL, в который нужно скопировать Style Sheet.

Найдите секцию Style Sheet и вставьте скопированный текст

в конец существующего списка Style Sheet.

Сохраните файл .PDL со скопированной секцией Style Sheet.

Когда вы откроете проект, связанный с обновленным файлом

.PDL, то увидите при выборе Options Style Sheet новый набор Style Sheet.

Создание DLL

DLL создаются аналогично файлам .EXE: компилируются файлы

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

Однако, DLL не имеют функции main и компонуются по другому. Ниже

рассказывается, как следует писать DLL.

LibMain, DllEntryPoint и WEP

В качестве основной точки входа для DLL должны предусматриваться функция LibMain (для 16-разрядных программ) или DllEntryPoint (для 32-разрядных). В случае 32-разрядных программ Windows

вызывает DllEntryPoint при каждой загрузке или выгрузке DLL, при

каждом присоединении или отсоединении от DLL дополнительных процессов или при создании/уничтожении внутри процесса нити.

Инициализация DLL практически целиком зависит от функции

конкретной DLL и может включать в себя следующие основные задачи:

Разблокировку сегмента данных с помощью UnlockData, если

она описывается как MOVEABLE (только для 16-битовых приложений).

Задание для DLL глобальных переменных (если она их использует).

Код инициализации выполняется только для первого приложения,

использующего DLL. Код запуска DLL автоматически инициализирует

локальную динамически распределяемую область памяти, поэтому в

LibMain не нужно включать соответствующий код. Функции LibMain

передаются следующие параметры:

int FAR PASCAL LibMain (HINSTANCE hInstance, WORD wDataSeg;

WORD cbHeapSize, LPSTR lpSmdLine)

hInstance - это описатель экземпляра DLL.

wDataSeg - это значение регистра сегмента данных (DS).

cbHeapSize - размер локальной динамически распределяемой

области памяти, заданной для DLL в файле определения модуля.

lpCmdLine - это дальний указатель командной строки, задан ной при загрузке DLL. Он почти всегда нулевой, так как DLL

обычно загружается автоматически и без параметров.

LibMain обычно возвращает значение 0 (успешная инициализация) или 1 (неуспешная инициализация). В последнем случае Windows

выгружает DLL из памяти.

Точкой выхода для 16-битовой DLL является функция WEP (Windows Exit Procedure). Эта функция для DLL не обязательна, так как

библиотеки исполняющей системы Borland C++ предусматривают ее по

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

DLL из памяти вы можете указать свою собственную функцию.

В Borland С++ WEP экспортировать не требуется. Borland С++

определяет свою собственную WEP, которая вызывает вашу WEP (если

она определена), а затем выполняет очистку системы. WEP имеет

следующий прототип:

int FAR PASCAL WEP (int nParameter)

где nParameter - это WEP_SYSTEMEXIT или WEP_FREE_DLL. WEP_SYSTEMEXIT указывает на завершение работы Windows, а WEP_FREE_DLL

только на выгрузку DLL. В случае успешного выполнения WEP возвращает 1. По этому значению Windows в настоящее время не выполняет

никаких действий.

Создание дочерних интерфейсных элементов

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

окон). По умолчанию автоматическое создание разрешено для всех

объектов ObjectWindows на базе TWindow, за исключением TDialog.

Если вы не строите в родительском окне дочерние объекты, они

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

Create или (в случае режимного окна) Execute. При этом создание

означает создание экземпляра интерфейсного элемента.

Создание интерфейсных элементов окна

После построения оконного объекта вам нужно сообщить Windows

о создании соответствующего интерфейсного элемента. Это можно

сделать путем вызова функции-элемента Create объекта, которая делает следующее:

Создает интерфейсный элемент.

Устанавливает HWindow в описатель интерфейсного элемента.

Устанавливает элементы Attr в фактическое состояние интерфейсного элемента (Style, ExStyle, X, Y, H, W).

Вызывает SetupWindow.

При создании интерфейсного элемента оконного объекта возможны две особых ситуации С++. Таким образом, для обработки проблем

с ресурсами или памятью вы должны заключить вызовы Create в блок

try/catch. Если окно создать невозможно, Create порождает особую

ситуацию TXInvalidWindow, а при невозможности создания дочернего

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

Основное окно приложения автоматически создается TApplication::InitInstance. Для создания основного окна вызов Create не требуется.

Создание интерфейсных объектов

Создание интерфейсного объекта с соответствующими интерфейсными элементами требует следующих шагов:

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

Создания интерфейсного элемента и информирования Windows о

создании нового интерфейсного объекта с новым интерфейсным элементом:

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

При создании режимного диалогового окна вы создаете интерфейсный элемент вызовом функции-элемента Execute интерфейсного объекта.

Связь между интерфейсным объектом и интерфейсным элементом

поддерживается через элемент данных HWindow - описатель окна.

Обычно в Windows вновь создаваемый интерфейсный элемент получает от Windows сообщение WM_CREATE и отвечает на него своей

инициализацией. Интерфейсный объекты ObjectWindows перехватывают

это сообщение и отвечают на него вызовом SetupWindow, где вы можете выполнить собственную инициализацию.

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

инициализацию после вызова функции SetupWindow базового класса.

До вызова функции SetupWindow базового класса и создания его дочерних окон HWindow будет недействительным (имеет значение NULL).

Из-за того, что большая часть инициализации выполняется в

конструкторе интерфейсного объекта, после создания этого объекта

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

Создание экземпляров шаблона класса

После определения шаблона класса вы можете создать любое

число экземпляров этого класса. Эти экземпляры можно использовать

для различных описаний шаблона, поиска различных заданных по

умолчанию файлов, просмотра различных каталогов и т.д. Сигнатура

конструктора шаблона класса всегда одинакова и имеет вид:

TplName name(LPCSTR desc, LPCSTR filt, LPCSTR dir, LPCSTR

ext, long flags);

где TplName - имя класса, заданного при определении шаблона класса, name - имя данного экземпляра, desc - описание текста шаблона, filt - строка, используемая для фильтрации имен файлов в текущем каталоге (одно или более выражений, разделенных точкой с

запятой), dir - заданный по умолчанию каталог для файлов документов, ext - расширение, задаваемое по умолчанию при сохранении

файлов, flags - режим открытия и создания документа:

Флаг Функция

dtAutoDelete	Закрывает и удаляет объект документа при закрытии последнего отображаемого элемента.
dtNoAutoView	Не создает автоматически заданный по умолчанию отображаемый элемент.
dtSingleView	Допускает только один отображаемый элемент на документ.
dtAutoOpen	Открывает документ при создании.
dtHidden	Скрывает шаблон в списке выбора пользователя.

Создание класса документа

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

соответствующих данных.

TDocument - это абстрактный базовый класс, обеспечивающий

данные функциональные возможности. Непосредственно создать его

экземпляр нельзя, поэтому необходимы производные классы. При

построении производного класса вызывается конструктор TDocument.

Этот конструктор воспринимает только один параметр TDocument*,

который указывает на родительский документ нового документа или

равен 0 (по умолчанию).

Обычно следует избегать переопределения функций TDocument,

так как они не описаны как virtual. Администратор документа обращается ко всем производным объектам TDocument как к фактическим

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

TDocument этой функции. Однако при переопределении виртуальной

функции TDocument (~TDocument, InStream, OutStream, Open, Close,

Commit, Revert, RootDocument, SetDocPath, SetDocPath, SetTitle,

GetProperty, IsDirty, IsOpen, CanClose, AttachStream и DetachStream) администратор документа корректно вызывает вашу функцию.

Если функция базового класса выполняет какие-то важные действия,

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

Создание класса отображаемого элемента

Пользователь почти никогда не взаимодействует непосредственно с документом. Он работает с интерфейсным объектом, таким как

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

Создание многоцелевого проекта

Создание многоцелевого проекта выполняется аналогично:

Создайте проект, используя описанные выше шаги.

Выберите Project New target. Выводится диалоговое окно New

Target.

Наберите имя для второй целевой платформы и выберите тип

(по умолчанию Standard). Выберите OK.

Создание новых классов sber_bank

Класс sber_bank может стать основой по которой будут созданы

другие классы:

Класс Потомки класса sber_bank

v v v

sber_bank broke_bank, cold_cash_inc;

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

объекте.

class sber_bank {

Объект sber_bank public:

double big_bucks;

...

< Deposit << };

$$$ <-------------------------------

<<

Данные > Withdraw >>

Функции элементы

Доступ к данным объекта выполняется подобно обращению к элементу

структуры в языке Си через селектор '.'.

Например:

class sber_bank {

public:

double big_bucks;

...

};

sber_bank my_bank;

Объект Данные

v v

my_bank.big_bucks = 1000000.00;

^

Селектор

Создание объекта принтера

Простейший способ создания объекта принтера состоит в описании в оконном объекте TPrinter*, который другие объекты в программе смогут использовать в целях печати (см. пример программы

PRINTING.CPP в каталоге OWLAPI\PRINTING).

Основное окно приложения инициализирует объект принтера и

использует заданный по умолчанию в WIN.INI. Однако в некоторых

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

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

Создание объекта распечатки

Создание объекта распечатки аналогично написанию функции-элемента Paint для оконного объекта: для генерации нужного

образа в контексту устройства используйте графические функции

Windows. Объект окна выводит содержимое и управляет взаимодействием с экраном устройства. Контекст устройства объекта распечатки аналогичным образом изолирует вас от устройства печати. Чтобы создать объект распечатки:

Создайте из TPrintout новый тип объекта и переопределите

функцию-элемент PrintPage. В простейшем случае этого достаточно.

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

Текущая страница печати передается PrintPage в качестве параметра.

Объект распечатки имеет поля, содержащие размер страницы и

контекст устройства. Объект принтера устанавливает эти значения

вызовом функции-элемента SetPrintParams объекта распечатки. Контекст устройства объекта распечатки вам следует использовать при

любых вызовах графических функций Windows.

Создание потоковых объектов

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

Сделайте TStreamableBase виртуальной базой вашего класса

(прямо или косвенно).

Добавьте в определение класса макрокоманду

DECLARE_STREAMABLE.

Добавьте в один из своих исходных файлов макрокоманду

IMPLEMENT_STREAMABLE. Рекомендуется также добавление макрокоманды IMPLEMENT_CASTABLE.

Запишите в одном из своих исходных файлов определения

функций-элементов Read и Write.

Чтобы определить потоковый класс, вам нужно:

Включить файл objstrm.h.

Основывать свой класс на классе TStreamableBase.

Включите в свое определение класса макрокоманду

DECLARE_STREAMABLE, например:

#include <objstrm.h>

class Sample : public TStreamableBase

{

public:

// функции-элементы и т.д.

private:

int i;

DECLARE_STREAMABLE(IMPEXPMACRO, Sample, 1);

};

Классы, шаблоны и макрокоманды, необходимые для определения

потокового класса, предусмотрены в файле objstrm.h. Каждый потоковый класс должен наследовать (прямо или косвенно) из класса

TStreamableBase. В данном примере класс Sample наследует непосредственно из TStreamable. Класс, производный из Sample, не будет

явно наследовать из TStreamableBase, поскольку это уже делает

Sample. Если вы используете множественное наследование, то следует сделать TStreamableBase виртуальной базой. Это несколько увеличит классы, но никакого отрицательного эффекта не окажет.

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

DLL. Второй параметр - это имя определяемого класса, а третий номер версии для этого класса. Потоковый код не обращает внимание

на номер версии класса.

DECLARE_STREAMABLE добавляет в ваш класс конструктор, воспринимающий параметр типа Streamable. Он предназначен для применения в потоковом коде, и непосредственно не используется.

DECLARE_STREAMABLE создает также для вашего класса два экстрактора, так что вы можете записывать объекты для считывания их из

постоянных потоков. Для класса приведенного выше примера класса

Sample эти функции имеют следующие прототипы:

opstream& operator << { opstream&, const Sample& };

opstream& operator << { opstream&, const Sample* };

opstream& operator >> { opstream&, Sample& };

opstream& operator >> { opstream&, Sample*& };

Первый инсертер записывает объекты типа Sample. Второй записывает объекты, указываемые указателем на Sample. Это позволяет

вам использовать полиморфизм и полностью управлять потоками, то

есть полностью записывать объекты типов, производных от Sample.

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

действие, обратное инсертеру.)

Наконец, DECLARE_STREAMABLE создает на базе класса TStreamer

вложенный класс с именем Streamer, который определяет ядро потокового кода.

Создание приложения

Создание приложения с помощью AppExpert предусматривает следующие этапы:

Запустите IDE и выберите команду Project AppExpert. При

этом выводится диалоговое окно.

Наберите имя файла проекта.

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

проекта AppExpert (если он не существует, то создается). В

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

Щелкните "мышью" на OK. Выводится диалоговое окно AppExpert Application Generation Options.

Для генерации приложения Windows по умолчанию вы можете

щелкнуть "мышью" на кнопке Generate диалогового окна Options. Диалоговое окно Application Generation Options содержит слева список тем, а справа - краткое описание темы.

Кнопка Help позволяет вывести справочную информацию по теме.

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

("+" указывает на наличие подтемы, а "-" говорит о том,

что выведены все подтемы).

Выберите для приложения нужные параметры

Щелкните "мышью" на кнопке Generate диалогового окна Options.

Выводится диалоговое окно, подтверждающее генерацию кода.

Для генерации кода щелкните "мышью" на Yes. No возвращает

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

Выводится окно проекта, в котором перечислены некоторые из

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

приложение, выберите Project Make all. По умолчанию все

выполняемые файлы сохраняются в базовом каталоге.

Создание проекта

Использование администратора проектов не представляет затруднений. Для построения проекта:

Выберите имя для файла проекта (с помощью команды Project New Project. Наберите имя проекта и нажмите Tab.

Наберите имя первого целевого файла в проекте и выберите

его тип (.EXE, .DLL, .LIB, .HLP или файл EasyWin).

Выберите целевую платформу (Windows 3.x, DOS Standard или

DOS Overlay для 16-разрядных приложений или Win32 для

32-разрядных).

Если ваше приложение предназначено для DOS, задайте, если

это необходимо:

плавающую точку (компоновку F87.lib);

эмуляцию (компоновка EMU.LIB);

компоновку математических библиотек DOS (если требуется);

альтернативный способ компоновки C0Fx.OBJ (для всех моделей SS будет равно DS);

стандартные библиотеки, которые нужно использовать в

приложении;

библиотеки ObjectWindows;

библиотеку классов Borland С++;

библиотеки этапа выполнения;

библиотеки BWCC;

графический интерфейс Borland (BGI).

Чтобы использовать диагностическую версию библиотек, выберите Diagnosis.

Если необходима мультинитевая версия библиотеки исполняющей системы, выберите Multithread (в Win32).

Выберите модель памяти (Target Model).

Чтобы создать проект, щелкните "мышью" на OK.

Создание расширенного словаря: параметр /E

Для ускорения процесса компоновки больших файлов библиотек

(таких, как стандартная библиотека Cx.LIB), можно указать утилите

TLIB, что нужно создать расширенный словарь и подсоединить его к

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

на ваших дистрибутивных дисках содержат расширенный словарь.

Для создания расширенного словаря модифицируемой библиотеки

необходимо при добавлении, удалении или замене модулей в этой

библиотеке задать параметр /E при вызове утилиты TLIB. Для создания расширенного словаря существующей библиотеки, которую вы не

хотите модифицировать, нужно задать параметр /E и указать TLIB

удаление из библиотеки несуществующего модуля. При этом утилита

TLIB выдаст предупреждающее сообщение о том, что заданный модуль

в библиотеке не найден, но наряду с этим создаст расширенный словарь заданной библиотеки. Например, введите следующую строку:

tlib /E mylib -bogus

Если не использовать в командной строке TLIB параметр /e, то

утилита TLIB будет игнорировать отладочную информацию в библиотеке, имеющей расширенный словарь.

Создание Style Sheet

Чтобы создать Style Sheet, сделайте следующее:

Выберите в основном меню Options Style Sheet.

Щелкните "мышью" на Create. Наберите имя Style Sheet и

нажмите Enter.

Щелкните "мышью" на Edit. Выводится диалоговое окно Style

Sheet.

Отредактируйте параметры и выберите OK.

Создание типов документа

При создании приложения AppExpert, поддерживающего модуль

Doc/View, вы можете использовать ClassExpert создания классов

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

Создайте класс отображаемого элемента или используйте один

из трех предопределенных классов (TEditView, TListView или

TWindowView).

Запустите из своего проекта ClassExpert. Щелкните правой

кнопкой "мыши" в области классов, затем выберите в оперативном меню Create doc types.

Выберите View class. По умолчанию это класс TEditView,

TListView, TWindowView или ваш собственный класс.

Наберите описание типов файлов вашего документа. Этот

текст выводится в диалоговом окне File Open.

Наберите необходимые фильтры, разделив их запятыми. Эти

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

Наберите используемое по умолчанию расширение файла. Оно

будет использоваться при сохранении.

Чтобы задать стили документа/отображаемого элемента, щелкните "мышью" на командной кнопке Styles. Вы можете выбирать следующие стили:

Стиль Описание

dtAutoDelete	Удалять объект документа при закрытии последнего отображаемого элемента.
dtNoAutoView	Не создавать автоматически заданный по умолчанию тип отображаемого элемента.
dtSingleView	Обеспечивать только один отображаемый элемент на каждый документ.
dtAutoOpen	Открывает документ при его создании.
dtUpdateDir	Обновляет каталог диалога.
dtHidden	Скрывает шаблон в списке выбираемых пользователем шаблонов.
dtSelected	Указывает последний выбранный шаблон.
dtReadOnly	Выбирает при создании диалогового окна доступную только по чтению кнопку с независимой фиксацией.
dtOverWritePrompt	Запрашивает пользователя, можно ли перезаписать существующий файл (в диалоге Save As).
dtHideReadOnly	Скрывает кнопки с независимой фиксацией, доступные только по чтению.
dtPathMustExist	Позволяет пользователю набирать только существующие маршруты.
dtFileMusttExist	Позволяет пользователю набирать имена только существующих файлов.
dtCreatePrompt	Перед созданием нового документа выводит пользователю подсказку.
dtNoReadOnly	Возвращает заданный файл как доступный для записи.

Чтобы добавить тип документа в приложение, щелкните

"мышью" на Add. При этом будет обновлена структура основного исходного файла, в котором описываются типы документов. Документ/отображаемый элемент выводится в списке доступных типов.

Чтобы вернуться в ClassExpert, щелкните "мышью" на Close.

Создание указателя данного адреса "сегмент:смещение"

Как создать дальний указатель на конкретный адрес памяти

(конкретный адрес "сегмент:смещение")? Для этого можно воспользоваться встроенной библиотечной подпрограммой MK_FP, которая в качестве аргумента воспринимает сегмент и смещение, и возвращает дальний указатель. Например:

MK_FP(segment_value, offset_value)

Имея дальний указатель fp, вы можете получить значение сегмента полного адреса с помощью FP_SEG(fp) и значение смещения с

помощью FP_OFF(fp). Более полную информацию об этих трех библиотечных функциях Borland C++ можно найти в справочнике по библиотеке.

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

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

Спецификатор Формат

c	Символ или строка выводятся на экран в виде необработанных символов. Обычно непечатаемые символы выводятся в виде управляющих символов или в числовом формате. Этот параметр приводит к тому, что при выводе символов будет использоваться полный набор символов дисплея IBM.
d	Целое число выводится в виде десятичного значения.
f[#]	Формат с плавающей точкой с заданным числом цифр. Если вы не задаете число цифр, то используется столько цифр, сколько необходимо.
m	Выражение со ссылкой на память выводится в виде шестнадцатиричных байт.
md	Выражение со ссылкой на память выводится в виде десятичных байт.
P	Выводится необработанное значение указателя, показывающее сегмент, как имя регистра (если это возможно). Показывается также объект, на который указатель ссылается. Если управление форматом не задано, то это используется по умолчанию.
s	Выводится массив или указатель на массив символов (строка, заключенная в кавычки). Строка завершается нулевым символом.
x или h	Целое выводится в виде шестнадцатиричного значения.

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

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

Списки дочерних окон

Вы задаете родителя интерфейсного элемента во время его

конструирования. Родительский оконный объект является параметром

конструктора интерфейсного объекта. Дочерний оконный объект хранит в своем элементе данных Parent адрес своего родительского

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

элементе данных ChildList.

Получить доступ к дочерним окнам объекта вы можете с помощью

функций-итераторов. Функции элементы ForEach и FirstThat получают

в качестве первого аргумента указатель на функцию. Подробнее о

них рассказывается ниже.

Список операций

Список операций определяет, какие действия должна выполнять

утилита TLIB. Он состоит из последовательности заданных одна за

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

середине двухсимвольного обозначения операции или внутри имени.

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

суммарная длина строки не должна превышать предел в 127 символов,

установленный в DOS (в COMMAND.COM). Порядок следования операций

не имеет значения. Утилита TLIB всегда выполняет операции в следующем порядке:

Сначала выполняются все операции извлечения.

Затем выполняются все операции удаления.

И, наконец, выполняются все операции добавления.

Замена какого-либо модуля может быть произведена путем удаления его с последующим добавлением заменяющего модуля.

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

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

Символ Имя Описание действия

+	Добавление	Утилита TLIB добавляет заданный файл в библиотеку. Если расширение имени файла не задается, то подразумевается расширение .OBJ. Если сам файл является библиотекой (с расширением .LIB), то в результате выполнения операции все модули указанной библиотеки будут добавлены в полученную в результате библиотеку. Если добавляемый модуль уже существует, то TLIB отображает сообщение, но не добавляет новый модуль.
-	Удаление	Утилита TLIB удаляет заданный модуль из библиотеки. Если этот модуль в библиотеке не существует, то TLIB отображает сообщение. Операция удаления требует задания только имени модуля. TLIB допускает ввод полного имени маршрута с указанием имени дисковода и расширения, но игнорирует все, за исключением имени модуля.
*	Извлечение	Утилита TLIB создает заданный файл путем копирования соответствующего модуля из библиотеки в файл. Если этот модуль не существует, то TLIB отображает сообщение, но файла не создает. Если файл с заданным именем уже существует, то он затирается, а на его место записывается новый.
-* *-	Извлечение и удаление	Утилита TLIB копирует заданный модуль в файл с соответствующим именем, а затем удаляет его из библиотеки. Данная операция представляет собой сокращенный путь для последовательного выполнения операции извлечения с последующей операцией удаления.
-+ +-	Замена	Утилита TLIB заменяет заданный модуль на соответствующий файл. Данная операция представляет собой сокращенный путь для последовательного выполнения операции удаления с последующей операцией добавления.

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

Справочная библиотека по функциям для DOS

absread	Читает секторы диска с абсолютной адресацией #include <dos.h> int absread(int drive, int nsects, long lsect, void *buffer);
abswrite	Записывает секторы диска с абсолютной адресацией #include <dos.h> int abswrite (int drive,int nsects,int lsect, void *buffer);
allocmem, _dos_allocmem	Выделяет сегмент памяти DOS #include <dos.h> int allocmem(unsigned size, unsigned *segp); unsigned _dos_allocmem(unsigned size, unsigned *segp);
bioscom	Выполняет последовательный ввод/вывод #include <bios.h> int bioscom(int cmd, char abyte, int port);
_bios_ disk	Запрашивает дисковые операции BIOS #include <bios.h> insigned _bios_disk(unsigned cmd, struct diskinfo_t*dinfo);
biosdisk	Вызывает дисковые операции BIOS #include <bios.h> int biosdisk(int cmd, int drive, int head, int track, int sector, int nsects, void *buffer);
bioskey	Интерфейс клавиатуры, напрямую использующий операции BIOS #include <bios.h> int bioskey(int cmd);
_bios_keybrd	Интерфейс клавиатуры, напрямую использующий операции BIOS #include <bios.h> unsigned _bios_keybrd(unsigned cmd);
biosprint	Управляет вводом/выводом принтера при помощи BIOS #include <bios.h> int biosprint(int cmd,int abyte,int port);
_bios_printer	Управляет вводом-выводом принтера при помощи BIOS #include <bios.h> unsigned _bios_printer(int cmd,int port, int abyte);
_bios_serialcom	Выполняет последовательный ввод-вывод #include <bios.h> unsigned _bios_serialcom(int cmd, int port, char abyte);
brk	Изменяет объем памяти, выделенный для сегмента данных #include <alloc.h> int brk(void *addr);
coreleft	Возвращает размер свободной оперативной памяти в крохотной (tiny), малой (small) и средней (medium) моделях памяти: #include <alloc.h> unsigned coreleft(void); в компактной (compact), большой(large) и огром- ной (huge) моделях памяти: #include <alloc.h> unsigned long coreleft(void);
delay	Приостанавливает выполнение программы на заданный интервал (в миллисекундах) #include <dos.h> void delay(unsigned milliseconds);
farcoreleft	Возвращает размер свободной памяти в куче с дальней адресацией #include <alloc.h> unsigned long farcoreleft(void);
farheapcheck	Пpосматривает и проверяет кучу с дальней адресацией #include <alloc.h> int farheapcheck(void);
farheapcheckfree	Проверяет свободные блоки кучи c дальней адресацией на постоянное значение #include <alloc.h> int fsrheapcheckfree (unsigned int fillvalue)
farheapchecknode	Просматривает и проверяет отдельный узел кучи с дальней адресацией #include <alloc.h> int farheapchecknode (void *node)
farheapfillfree	Заполняет свободные блоки кучи с дальней адресацией определенным значением #include <alloc.h> int farheapfillfree (unsigned int fillvalue)
farheapwalk	Используется для перемещения по куче с дальней адресацией от узла к узлу #include <alloc.h> int farheapwolk(struct farheapinfo *hi)
freemem,_dos_freemem	Освобождает предварительно выделенный блок памяти DOS #include<dos.h> int freemem(unsigned segx); unsigned _dos_freemem(unsigned segx);
harderr,hardresume,hardreth	Устанавливает и обрабатывает аппаратную ошибку подпрограммы взаимодействия с внешним устройством #include <dos.h> void harderr(int(*handler)()); void hardresume(int axret); void hardreth(int retn);
_harderr	Устанавливает обработчик аппаратной ошибки #include<dos.h> void _harderr(int (far *handler)());
_hardresume	Функция обработки ошибок аппаратуры #include <dos.h> void _hardresume(int rescode);
_hardretn	Функция обработки ошибки аппаратуры #include <dos.h> void _hardretn(int retn);
keep,_dos_keep	Осуществляет выход в DOS, оставляя программу резидентной #include <dos.h> void keep(unsigned char status, unsigned size); void _dos_keep(unsigned char status, unsigned size);
nosound	Отключает динамик компьютера #include <dos.h> void nosound(void);
_OvrInitEms	Инициализирует систему подкачки отображаемой памяти для программы менеджера оверлеев #include <dos.h> int cdecl far _OvrlnitEms (unsigned emsHandle, unsigned fistPage, unsigned pages);
_OvrlnitExt	Инициализирует систему подкачки отображаемой памяти для программы менеджера оверлеев #include <dos.h> int cdecl far _OvrlnitExt(unsigned long startAddress, unsigned long length);
randbrd	Чтение произвольного блока #include <dos.h> int randbrd(struct fcb *fcb, int rcnt);
randbwr	Запись произвольного блока #include <dos.h> int randbwr (struct fcb *fcb, int rcnt);
sbrk	Изменяет размещение сегмента данных #include <alloc.h> void *sbrk(int incr);
setblock _dos_setblock	Изменяет размер предварительно распределенной области памяти #include<dos.h> int setblock(unsigned segx, unsigned newsize); unsigned_dos_setblock(unsigned newsize, unsigned segx,unsigned *maxp);
sound	Устанавливает динамик на заданную частоту #include <dos.h> void sound(unsigned frequency);

Справочная библиотека по графическим функциям DOS

arc	Рисует дугу #include <graphiсs.h> void far arc (int x, int y, int stangle, int endangle, int radius);
bar	Рисует двумерную полосу #include <graphics.h> #include <conio.h> void far bar(int left, int top, int right, int bottom);
bar3d	Рисует трехмерный столбец #include <graphics.h> void far bar3d (int left, int top, int right, int bottom, int depth, int topflag);
circle	Вычерчивает окружность заданного радиуса из заданного центра #include <graphics.h> void far circle(int x, int y, int radius);
cleardevice	Очищает графический экран #include <graphics.h> void far cleardevice(void);
clearviewport	Очищает текущее окно (viewport) #include <graphics.h> void far clearviewport(void);
closegraph	Завершает работу с графической системой #include <graphics.h> void far closegraph(void);
detectgraph	Определяет путем проверки аппаратуры - какой графический драйвер и режим использовать #include <graphics.h> void far detectgraph(int far *graphdriver, int far *graphmode);
drawpoly	Вычерчивает контур многоугольника #include <graphics.h> void far drawpoly(int numpoints, int far *polypoints);
ellipse	Рисует эллиптическую дугу #include <graphics.h> void far ellipse(int x, int y, int stangle, int endangle, int xradius, int yradius);
fillellipse	Чертит и закрашивает эллипс #include<graphics.h> void far fillellipse(int x, int y, int xradius, int yradius);
fillpoly	Вычерчивает и закрашивает многоугольник #include<graphics.h> void far fillpoly(int numpoints, int far *polypoints);
floodfill	Заполняет методом "лавины" ограниченную область #include<graphics.h> void far floodfill(int x, int y, int border);
getarccoords	Возвращает координаты последнего обращения к функции arc #include<graphics.h> void far getarccoords(struct arccoordstype far *arccoords);
getaspectratio	Возвращает коэффициент сжатия текущего графиче- ского режима #include<graphics.h> void far getaspectratio(int far *xasp, int far *yasp);
getbkcolor	Возвращает текущий цвет фона #include<graphics.h> void far getbkcolor(void);
getcolor	Возвращает текущий цвет рисования #include<graphics.h> int far getcolor(void);
getdefaultpalette	Возвращает структуру определения палитры #include<graphics.h> struct palettetype *far getdefaultpalette(void)
getdrivername	Возвращает указатель на строку, содержащую имя текущего графического драйвера #include<graphics,.h> char *far getdrivername(void)
getfillpattern	Копирует в память описанный пользователем шаблон заполнения #include<graphics.h> void far getfillpattern(char far *pattern);
getfillsettings	Получает информацию о текущих шаблоне и цвете заполнения #include<graphics.h> void far getfillsettings(struct fillsettingstype far *fillinfo);
getgraphmode	Возвращает текущий графический режим #include<graphics.h> int far getgraphmode(void);
getimage	Сохраняет битовый образ некоторой области экрана в памяти #include<graphics.h> void far getimage(int left, int top, int right, int bottom, void far *bitmap);
getlinesettings	Получает текущий тип линии, шаблон и толщину #include<graphics.h> void far getlinesettings(struct linesettingstype far *lineinfo);
getmaxcolor	Возвращает максимальное значение цвета, которое можно передать функции setcolor #include<graphics.h> int far getmaxcolor(void);
getmaxmode	Возвращает максимальный номер режима для текущего драйвера #include<graphics.h> int far getmaxmode(void);
getmaxx	Возвращает максимальную координату экрана по x #include<graphics.h> int far getmaxx(void);
getmaxy	Возвращает максимальную координату экрана по y #include<graphics.h> int far getmaxy(void)
getmodename	Возвращает указатель на строку, содержащую имя заданного графического режима #include<graphics.h> char *far getmodename(int mode_number);
getmoderange	Получает диапазон режимов для заданного графического драйвера #include<graphics.h> void far getmoderange(int graphdriver, int far *lomode, int far *himode);
getpalette	Получает информацию о текущей палитре #include<graphics.h> void far getpalette(struct palettetype far *palette);
getpalettesize	Возвращает размер таблицы просмотра цветов палитры #include<graphics.h> int far getpalettesize(void);
getpixel	Возвращает цвет заданной точки #include<graphics.h> unsigned far getpixel(int x, int y);
gettextsettings	Получает информацию о текущем графическом текстовом шрифте #include<graphics.h> void far gettextsettings(struct textsettingstype far *texttypeinfo);
getviewsettings	Получает информацию о текущем окне (viewport) #include<graphics.h> void far getviewsettings(struct viewporttype far *viewport);
getx	Возвращает координату x текущей графической позиции #include<graphics.h> int far getx(void);
gety	Возвращает координату y текущей графической позиции #include<graphics.h> int far gety(void);
graphdefaults	Сбрасывает все графические параметры в их значения по умолчанию #include<graphics.h> void far graphdefaults(void);
grapherrormsg	Возвращает указатель на строку сообщения об ошибке #include<graphics.h> char *far grapherrormsg(int errorcode);
_graphfreemem	Подключает функции пользователя для освобождения графической памяти #include<graphics.h> void far _graphfreemem(void far *ptr, unsigned size);
_graphgetmem	Подключает функции пользователя для освобождения графической памяти #include<graphics.h> void far *far _graphgetmem(unsigned size);
graphresult	Возвращает код ошибки последней неудачной графической операции #include<graphics.h> int far graphresult(void);
imagesize	Возвращает количество байт, необходимых для хранения битового образа #include<graphics.h> unsigned far imagesize(int left, int top, int right, int bottom);
initgraph	Инициализирует графическую систему #include<graphics.h> void far initgraph(int far *graphdriver, int far *graphmode, char far *pathtodriver);
installuserdriver	Устанавливает дополнительный драйвер устройства в таблицу драйверов устройства BGI #include<graphics.h> int far installuserdriver( char far *name, int huge (*detect)(void));
installuserfont	Загружает шрифтовый файл (.CHR), который не встроен в систему BGI #include<graphics.h> int far installuserfont(char far *name);
line	Вычерчивает линию между двумя заданными точками #include<graphics.h> void far line(int x1, int y1, int x2, int y2);
linerel	Чертит линию на заданное расстояние от текущей позиции (CP) #include<graphics.h> void far linerel(int dx, int dy);
lineto	Чертит линию от текущей позиции (CP) в точку (x,y) #include<graphics.h> void far lineto(int x, int y);
moverel	Перемещает текущую позицию (CP) на заданное относительное расстояние #include<graphics.h> void far moverel(int dx,int dy);
moveto	Перемещает текущую позицию (СР) в точку (x,y) #include <graphics.h> void far moveto(int x,int y);
outtext	Выводит строку в окно (viewport) #include<graphics.h> void far outtext(char far *textstring);
outtextxy	Выводит строку в указанной области #include<graphics.h> void far outtextxy(int x, int y, char far *textstring);
pieslice	Вычерчивает и заполняет сектор круга #include<graphics.h> void far pieslice(int x, int y, int stangle, int endangle, int radius);
putimage	Выводит на экран битовый образ #include<graphics.h> void far putimage(int left, int top, void far *bitmap, int op);
putpixel	Выводит пиксель в заданной точке экрана #include<graphics.h> void far putpixel(int x, int y,int color);
rectangle	Вычерчивает прямоугольник #include<graphics.h> void far rectangle(int left, int top, int right,int bottom);
registerbgidriver	Связывает загруженный пользователем или встроенный в систему драйвер графической системы с самой графической системой #include<graphics.h> int registerbgidriver(void (*driver)(void));
registerbgifont	Регистрирует скомпонованные коды шрифта #include<graphics.h> int registerbgifont(void (*font)(void));
restorecrtmode	Восстанавливает режим монитора таким, каким он был до вызова initgraph #include<graphics.h> void far restorecrtmode(void);
sector	Вычерчивает и заполняет сектор эллипса #include<graphics.h> void far sector(int x, int y, int stangle, int endangle, int xradius, int yradius);
setactivepage	Устанавливает активную для графического вывода страницу #include<graphics.h> void far setactivepage(int page);
setallpalette	Изменяет все цвета палитры на заданные #include<graphics.h> void far setallpalette(struct palettetype far *palette);
setaspectratio	Изменяет значение по умолчанию коэффициента сжатия #include<graphics.h> void far setaspectratio(int xasp, int yasp);
setbkcolor	Устанавливает текущий цвет фона, используя палитру #include<graphics.h> void far setbkcolor(int color);
setcolor	Устанавливает текущий цвет вычерчивания, используя палитру #include<graphics.h> void far setcolor(int color);
setfillpattern	Устанавливает определенный пользователем шаблон заполнения #include<graphics.h> void far setfillpattern(char far *upattern, int color);
setfillstyle	Устанавливает шаблон и цвет заполнения #include<graphics.h> void far setfillstyle(int pattern, int color);
setgraphbufsize	Изменяет размер внутреннего графического буфера #include<graphics.h> unsigned far setgraphbufsize(unsigned bufsize);
setgraphmode	Переводит систему в графический режим и очищает экран #include<graphics.h> void far setgraphmode(int mode);
setlinestyle	Устанавливает текущие толщину и тип линии #include<graphics.h> void far setlinestyle(int linestyle, unsigned apattern, int thickness);
setpalette	Изменяет один цвет палитры #include <graphics.h> void far setpalette(int colornum, int color);
setrgbpalette	Позволяет пользователю определять цвета для IBM 8514 #include <graphics.h> void far setrgbpalette(int clornum,int red, int green,int blue);
settextjustify	Выравнивает строки текста для графических функций #include <graphics.h> void far settextjustify(int horiz, int vert);
settextstyle	Устанавливает текущие текстовые характеристики для графического вывода #include <graphics.h> void far settextstyle(int font, int direction, int charsize);
setusercharsize	Задает пользовательский коэффициент увеличения ширины и высоты символов для штриховых шрифтов #include <graphics.h> void far setusercharsize(int multх, int divх, int multy, int divy);
setviewport	Устанавливает для графического вывода текущее графическое окно #include <graphics.h> void far setviewport(int left, int top, int right, int bottom, int clip);
setvisualpage	Устанавливает номер отображаемой страницы #include <graphics.h> void far setvisualpage(int page);
setwritemode	Устанавливает режим записи для рисуемой линии в графическом режиме #include <graphics.h> void far setwritemode(int mode);
textheight	Возвращает высоту строки в точках растра #include <graphics.h> int far textheight(char far *textstring);
textwidth	Возвращает ширину строки в точках растра #include <graphics.h> int far textwidth(char far *textstring);

Назад | Содержание | Вперед

Справочная библиотека по языку Borland C++

Перед тем как представить полную справочную библиотеку функций языка программирования Borland С++, рассмотрим функцию main,

занимающую особое место в данном перечне.

Справочная информация по программированию

Примечание: настоящий раздел представляет собой сводный обзор основных правил, обычно, используемых для написания программы, и обзор некоторых тем, часто необходимых в качестве справочного материала. Более строгую информацию можно найти в руководстве по Borland C++ 4.0 или в быстрой интерактивной помощи Help. В основном информация этого раздела применима и для Турбо С++ и Borland C++ 4.0.

Версия 4.0 Borland C++ поможет вам создавать 16- и 32-битовые приложения для операционных систем Chicago и Windows NT. Это очень гибкая и открытая среда разработчика, обеспечивающая простое взаимодействие с ней. Интегрированная среда Borland C++ обладает по-настоящему открытой архитектурой и имеет большой набор

инструментов визуального программирования.

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

позволяет программистам приспособить под свои нужды панель инструментальных средств.

В Borland C++ 4.0 предлагаются графические меню, подобные

используемым в Quattro Pro и Paradox. При нажатии правой кнопки

"мыши" появляется панель с другим набором инструментальных средств программирования.

В исключительных ситуациях версия 4.0 перехватывает и распознает ошибки, позволяя программистам аккуратно выходить из любого затруднения. Новая версия включает в себя Object Windows 2.0 - объектно-ориентированную библиотеку, поддерживающую 32-разрядное программирование и перенос приложений между 16- и 32-разрядным режимом Windows.

Работа компилятора Borland C++ начинается с просмотра текста

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

Ниже, в справочных таблицах, даются наиболее важные сведения

по конкретной реализации С++ фирмы Borland. Начинаются они с перечня ключевых слов, которые не должны использоваться в качестве обычных имен идентификаторов.

Справочник по функциям Borland С++

abort	Экстренно завершает программу DOS UNIX Win16 #include <stdlib.h> OS/2 Win32 void abort(void); ANSI C++ ANSI C
abs	Вычисляет абсолютное значение целочисленного аргумента DOS UNIX Win16 #include <stdlib.h> OS/2 Win32 int abs(int x) ANSI C++ ANSI C
access	Определяет доступность файла DOS UNIX Win16 #include <io.h> OS/2 Win32 int access(const char *filename,int amode);
acos, acosl	Вычисляет арккосинус acos #include <math.h> double acos(double x); DOS UNIX Win16 OS/2 Win32 ANSI C++ ANSI C ---***--- acosl #include <math.h> long double acosl(long double x); DOS Win16 OS/2 Win32
alloca	Выделяет временную область стека DOS UNIX Win16 #include<malloc.h> OS/2 Win32 void *alloca(size_t size);
asctime	Преобразует дату и время в формат ASCII DOS UNIX Win16 #include <time.h> OS/2 Win32 char *asctime(const struct tm *tblock); ANSI C++ ANSI C
asin, asinl	Вычисляет арксинус asin #include <math.h> double asin(double x); DOS UNIX Win16 OS/2 Win32 ANSI C++ ANSI C ---***--- asinl #inclyde <math.h> long double asinl(long double x); DOS Win16 OS/2 C++ Win32
assert	Проверяет условия и прерывает, при необходимости, выполнение программы DOS UNIX Win16 OS/2 Win32 #include <assert.h> ANSI C++ ANSI C void assert(int test);
atan,atanl	Вычисляет арктангенс atan #include <math.h> double atan(double x) DOS UNIX Win16 OS/2 Win32 ANSI C++ ANSI C ---***--- atanl #include <math.h> long double atanl(long double x); DOS UNIX Win16 OS/2 Win32 ANSI C++ ANSI C
atan2, atan2l	Вычисляет арктангенс y/x atan2 #include <math.h> double atan2(double y, double x); DOS UNIX Win16 OS/2 Win32 ANSI C++ ANSI C ---***--- atan2l #include<math.h> long double atan2l(long double y, DOS UNIX Win16 long double x); OS/2
atexit	Регистрирует функцию выхода DOS Win16 #include <stdlib.h> OS/2 Win32 int atexit(_USERENTRY * func)(void)); ANSI C++ ANSI C
atof, _atold	Преобразует строку в число с плавающей точкой atof #include <math.h> double atof(const char *s); DOS UNIX Win16 OS/2 Win32 ANSI C++ ANSI C _atold #include <math.h> long double _atold(const char *s); DOS Win16 OS/2 Win32
atoi	Преобразует строку в число типа integer DOS UNIX Win16 #include <stdlib.h> OS/2 Win32 int atoi(const char *s); ANSI C++ ANSI C
atol	Преобразует строку в число типа long DOS UNIX Win16 #include <stdlib.h> OS/2 Win32 long atol(char *s); ANSI C++ ANSI C
_atold	смотpи atof
bdos	Обеспечивает доступ к системным вызовам DOS DOS Win16 #include <dos.h> int bdosptr(int dosfun,void *argument, unsigned dosal);
bdosptr	Обеспечивает доступ к системным вызовам DOS DOS UNIX Win16 #include <dos.h> OS/2 int bdosptr(int dosfun, void *argument, unsigned dosal);
_beginthread	Начинает обработку новой последовательности #include <process.h> OS/2 C++ Win32 unsigned long _begihthread (_USERENTRY (*start_adress)(void *),unsigned stack_size, void *arglist)
_beginthreadNT	Начинает обработку новой последовательности под WindowsNT Win32 #include <process.h> unsigned long _beginthreadNT (void(_USENTRY * start_adress) (void *),unsigned stack_size, void *arglist, void *security_attrib, unsignet long create_fiagss, unsigned long *thead_id);
biosequip	Проверяет оборудование DOS Win16 #include <bios.h> int biosequip(void);
_bios_equiplist	Проверяет оборудование DOS Win16 #include <bios.h> unsigned _bios_equiplist(void);
bioskey	Интерфейс клавиатуры, напрямую использующий операции BIOS DOS Win16 #include <bios.h> int bioskey(int cmd);
biosmemory	Возвращает размер памяти DOS Win16 #include <bios.h> int biosmemory(void);
_bios_memsize	Возвращает размер памяти DOS Win16 #include <bios.h> unsigned _bios_memsize(void);
biostime	Читает или устанавливает таймер BIOS DOS Win16 #include <bios.h> long biostime(int cmd, long newtime);
_bios_timeofday	Читает или устанавливает таймер BIOS DOS Win16 #include <bios.h> unsigned _bios_timeofday(int cmd,long *timep);
bsearch	Осуществляет двоичный поиск в массиве DOS UNIX Win16 #include <stdlib.h> OS/2 Win32 void *bsearch(const void *key,const void *base, ANSI C++ ANSI C size_t nelem, size_t width, int (_USERENTRY *fсmp)(const void *, const void *));
cabs, cabsl	Вычисляет абсолютные значения комплексного числа cabs #include <math.h> DOS UNIX Win16 double cabs(struct complex z); D OS/2 Win32 ---***--- cabcl #include <math.h> DOS Win16 long double cabsl(struct _complexl z); OS/2 Win32
calloc	Выделяет оперативную память DOS UNIX Win16 #include <stdlib.h> Win32 ANCI C void *calloc(size_t nitems, size_t size); ANCI C++ OS/2
ceil, ceill	Округляет значение аргумента в большую сторону ceil #include <math.h> double ceil(double x); DOS UNIX Win16 OS/2 Win32 ANSI C++ ANSI C ---***--- ceill #include <math.h> long double ceill(long double x); DOS Win16 Win32 OS/2
_c_exit	Освобождает системные ресурсы (как _exit), но не завершает программу. DOS Win16 OS/2 Win32 #include <process.h> void _c_exit(void);
_cexit	Освобождает системные pесуpсы но не завеpшает пpогpамму. DOS Win16 #include <process.h> OS/2 Win32 void _cexit(void)
cgets	Считывает строку с консоли DOS #include <conio.h> OS/2 Win32 char *cgets(char *str);
_chain_intr	Обеспечивает связь с новым обработчиком прерываний DOS Win16 #include <dos.h> void _chain_intr(void(interrupt far *newhandler)());
chdir	Изменяет текущий каталог DOS UNIX Win16 #include <dir.h> OS/2 Win32 int chdir (const char *path);
_chdrive	Устанавливает текущий диск DOS Win16 #include <direct.h> OS/2 Win32 int _chdrive(int drive);
_chmod	смотpи _rtl_chmod Изменяет атрибуты файла DOS
chmod	Изменяет режим доступа к файлу DOS UNIX Win16 #include <sys\stat.h> OS/2 Win32 int chmod(const char *path, int amode);
chsize	Изменяет размер файла DOS Win16 #include <io.h> OS/2 Win32 int chsize(int handle, long size);
_clear87	Очищает слово состояния операций с плавающей точкой DOS Win16 OS/2 Win32 #include <float.h>
clearerr	Сбрасывает индикацию ошибки DOS UNIX Win16 #include <stdio.h> OS/2 Win32 void clearerr(FILE *stream); ANSI C++ ANSI C
clock	Определяет процессорное время DOS Win16 #include <time.h> OS/2 Win32 clock_t clock(void); ANSI C++ ANSI C
_close	Смотpи _rtl_close Закрывает файл
close	Закpывает файл DOS Win16 UNIX #include <io.h> OS/2 Win32 int close(int handle);
closedir	Закрывает поток ввода-вывода каталога DOS UNIX Win16 #include <dirent.h> OS/2 C++ Win32 void closedir(DIR *dirp);
clreol	Очищает конец строки в текстовом окне DOS Win16 #include <conio.h> OS/2 Win32 void clreol(void);
clrscr	Очищает окно в текстовом режиме DOS Win16 #include <conio.h> OS/2 Win32 void clrscr(void); complex conj(complex x);
_control87	Манипулирует словом управления операций с плавающей точкой DOS Win16 #include <float.h> OS/2 Win32 unsigned int _control87(unsigned int newcw, unsigned int mask);
cos, cosl	Вычисляет косинус cos Вещественная версия #include <math.h> DOS UNIX Win16 double cos(double x); OS/2 Win32 ANSI C++ ANSI C ---***--- cosl #include <math.h> long double cosl(long double x); DOS Win16 OS/2 Win32
cosh, coshl	Вычисляет гиперболический косинус cosh #include <math.h> double cosh(double x); DOS UNIX Win16 OS/2 Win32 ANSI C++ ANSI C ---***--- coshl #include <math.h> long double coshl(long double x); DOS Win16 OS/2 Win32
country	Возвращает информацию, зависящую от страны DOS Win16 #include <dos.h> OS/2 struct country *country(int xcode, struct COUNTRY *cp);
cprintf	Осуществляет форматированный вывод на экран DOS #include <conio.h> OS/2 Win32 int cprintf(const char *format[,аргумент,...]);
cputs	Выводит строку на экран DOS #include <conio.h> OS/2 Win32 int cputs(const char *str);
_creat	Смотpи _rtl_crerat
creat	Создает новый файл или перезаписывает существующий DOS UNIX Win16 #include<io.h> OS/2 Win32 int creat(const char *path, int amode);
creatnew	Создает новый файл DOS Win16 #include<is.h> OS/2 Win32 int creatnew(const char *path, int mode);
creattemp	Создает уникальный файл в каталоге, определенном в маршруте DOS Win16 #include<io.h> OS/2 Win32 int creattemp(char *path, int attrib);
_crotl,_crotr	Пеpевоpачивает и изменяет символы в пеpеменных налево или напpаво. DOS Win16 #include<stdlib.h> OS/2 Win32 unsigned char _crotl(unsigned char val, int count) unsigned char _crotr(unsigned char val, int count)
cscanf	Просматривает и форматирует ввод с консоли DOS Win16 #include <conio.h> OS/2 Win32 int cscanf(char *format[,адрес,...]);
ctime	Преобразует дату и время в строку DOS UNIX Win16 #include <time.h> OS/2 Win32 char *ctime(const time_t *time); ANSI C++ ANSI C
ctrlbrk	Устанавливает программу обработки Ctrl/Break DOS Win16 #include <dos.h> Win32 void ctrlbrk(int (*handler)(void));
cwait	Заканчивает пpиостановку подпpогpамм OS/2 Win32 #include<process.h> int cwit(int *statloc, int pid, int action);
delline	Удаляет строку в текстовом окне DOS Win16 #include <conio.h> OS/2 Win32 void delline(void);
difftime	Вычисляет разницу между двумя моментами времени DOS UNIX Win16 OS/2 Win32 #include <time.h> ANSI C++ ANSI C double difftime(time_t time2, time_t time1);
disable, _disable, enable, _enable		Запрещает и разрешает прерывания DOS Win16 Win32 #include<dos.h> void disable(void); void _disable(void); void enable(void); void _enable(void);
div	Делит два целых числа, возвращая частное и остаток DOS Win16 OS/2 Win32 #include <stdlib.h> ANSI C++ ANSI C div_t div(int numer, int denom);
_dos_close	Закрывает файл DOS Win16 #include <dos.h> OS/2 C++ Win32 unsigned _dos_close(int handle);
_dos_commit	Записывает файл на диск DOS Win16 #include <dos.h> unsigned _dos_commit(int handle);
_dos_creat	Создает новый файл на месте уже существующего DOS Win16 #include <dos.h,io.h> OS/2 unsigned _dos_creat (const shar *path,int attrib,int *handhelp);
_dos_creatnew	Cоздает новый файл DOS Win16 #include <dos.h> OS/2 unsigned _dos_creatnew(const char *path, int attrib,int *handlep);
dosexterr	Получает расширенную информацию об ошибке DOS DOS Win16 #include <dos.h> int dosexterr(struct DOSERROR *eblkp);
_dos_findfirst	Выполняет поиск в каталоге диска DOS Win16 #include <dos.h> OS/2 unsigned _dos_findfirst(const char *pathname, int attrib,struct find_t *ffblk);
_dos_findnext	Продолжает поиск, начатый _dos_findfirst DOS Win16 #include <dos.h> OS/2 unsigned _dos_findnext(struct find_t *ffblk);
_dos_getdate,	Изменяет системную дату. _dos_setdate, getdate,setdate #include <dos.h> void _dos_getdate(struct dosdate_t *datep); DOS Win16 unsigned _dos _setdate(struct dosdate_t *datep); OS/2 void getdate(struct date *datep); void setdate(struct date *datep);
_dos_getdiskfree	Определяет свободное пространство на диске DOS Win16 #include <dos.h> OS/2 unsigned _dos_getdiskfree(unsigned char drive, struct diskfree_t *dtable);
_dos_getdrive,	Заменяет текущий диск _dos_setdrive #include <dos.h> DOS Win16 void _dos_getdrive(unsigned *drivep); OS/2 void _dos_setdrive(unsigned drivep, unsigned *ndrives);
_dos_getfileattr,	Изменяет pежим доступа к файлу. _dos_setfileattr #include <dos.h> DOS Win16 int _dos_getfileattr(const char *path, OS/2 unsigned *attribp); int _dos_setfileattr(const char path, unsigned attrib);
_dos_getftime,	Изменяет дату и время создания файла _dos_setftime #include <dos.h> DOS Win16 unsigned _dos_getftime(int handle, OS/2 unsigned *datep,unsigned *timep); unsigned _dos_setftime(int handle, unsigned date,unsigned time);
_dos_gettime,	Изменяет системное время _dos_settime #include <dos.h> DOS Win16 void _dos_gettime(struct dostime_t *timep); OS/2 unsigned _dos_settime(struct dostime_t *timep);
_dos_getvect	Получает вектор прерывания DOS Win16 #include <dos.h> OS/2 void interrupt(*_dos_getvect(unsigned interruptno)) ();
_dos_open	Открывает и подготавливает заданный файл для чтения или записи DOS Win16 #include <fcntl.h> #include <share.h> #include <dos.h> unsigned _dos_open(const char *filename, unsigned oflags,int *handlep);
_dos_read	Считывает данные из файла DOS Win16 #include <dos.h,io.h> OS/2 unsigned _dos_read(int handle,void far *buf, unsigned *nread);
_dos_setdate	Смотpи _dos_getdate
_dos_setdrive	Смотpи _dos_getdrive
_dos_setfileattr	Смотpи _dos_getfileattr
_dos_setftime	Смотpи _dos_setftime
_dos_gettime	Смотpи _dos_gettime
_dos_setvect	Устанавливает значение вектоpа прерывания DOS UNIX Win16 #include <dos.h> void _dos_setvect(unsigned interruptno, void iterrupt (*isr) ());
dostounix	Преобразует дату и время в формат UNIX DOS Win16 #include <dos.h> long dostounix(struct date *d, struct time *t);
_dos_write	Записывает в файл DOS Win16 #include <dos.h> OS/2 unsigned _dos_write (int handle, const void_ _far *buf,unsigned len unsigned *nwritten);
dup	Дублирует описатель файла DOS UNIX Win16 #include <io.h> OS/2 Win32 int dup(int handle);
dup2	Дублирует описатель файла (oldhandle) в новый (newhandle) DOS UNIX Win16 OS/2 Win32 #include <io.h> int dup2(int oldhandle,int newhandle);
ecvt	Преобразует число с плавающей точкой в строку DOS UNIX Win16 #include <stdlib.h> OS/2 Win32 char *ecvt(double value, int ndig, int *dec, int *sign);
__emit__	Вставляет литерные значения прямо в объектный код DOS UNIX Win16 OS/2 Win32 #include <dos.h> void __emit__(аргумент,...);
enable,_enable	Смотpи disable
_endtfread	Заканчивает обpаботку подпpогpаммы #include <process.h> OS/2 Win32 void _endthread (void);
eof	Контролирует достижение конца файла DOS Win16 #include <io.h> OS/2 Win32 int eof(int handle);
exec...	Загружает и выполняет другие программы DOS #include <process.h> OS/2 Win32 int execl(char *path, char *arg0,*arg1,..., *argn, NULL ); int execle(char *path, char *arg0,*arg1,..., *argn, NULL, char **env); int execlp(char *path, char *arg0,*arg1,..., *argn, NULL ); int execlpe(char *path, char *arg0,*arg1,..., *argn, NULL, char **env); int execv(char *path, char *arg[]); int execve(char *path, char *arg[],char **env); int execvp(char *path, char *arg[]); int execvpe(char *path,char *arg[],char **env);
_exit	Завершает выполнение программы DOS UNIX Win16 include <stdlib.h> OS/2 Win32 void _exit(int status);
exit	Завершает выполнение программы DOS UNIX Win16 #include <stdlib.h> OS/2 Win32 void exit(int status); ANSI C++ ANSI C
exp, expl	Вычисляет экспоненту (е в степени х) exp #include<math.h> double exp(double x); DOS UNIX Win16 OS/2 Win32 ANSI C++ ANSI C ---***--- expl #include<math.h> long double expl(long double x); DOS Win16 OS/2 Win32
_expand	Пpоизводит сжатие нескольких блоков #inclue <malloc.h> OS/2 Win32 void *_expand(void *block, size_t size);
fabs, fabsl	Определяет абсолютное значение числа с плавающей точкой fabs #include<math.h> double fabs(double x); DOS UNIX Win16 OS/2 Win32 ANSI C++ ANSI C ----***--- fabsl #include<math.h> long double fabls(long double x); DOS Win16 OS/2 Win32
farcalloc	Выделяет память из кучи c дальней адpесацией DOS Win16 #include <alloc.h> OS/2 void far *farcalloc(unsigned long nunits, unsigned long unitsz);
farfree	Освобождает блок из кучи с дальней адpесацией DOS Win16 #include <alloc.h> void farfree(void far *block);
farmalloc	Выделяет память в куче с дальней адресацией DOS Win16 #include <alloc.h> void far *farmalloc(unsigned long nbytes);
farrealloc	Регулирует размер блока в куче с дальней адресацией DOS Win16 OS/2 #include <alloc.h> void far *farrealloc(void far *oldblock, unsigned long nbytes);
fclose	Закрывает поток DOS UNIX Win16 #include<stdio.h> OS/2 Win32 int fclose(FILE *stream); ANSI C++ ANSI C
fcloseall	Закрывает открытые потоки DOS UNIX Win16 #include [<stdio.h> OS/2 Win32 int fcloseall(void);
fcvt	Преобразует число с плавающей точкой в строку DOS UNIX Win16 #include<stdlib.h> OS/2 Win32 char *fcvt(double value,int ndig,int *dec, int *sign);
fdopen	Связывает поток с описателем файла DOS UNIX Win16 #include<stdio.h> OS/2 Win32 FILE *fdopen(int handle, char *type);
feof	Обнаруживает конец файла в потоке DOS UNIX Win16 #include<stdio.h> OS/2 Win32 int feof(FILE *stream); ANSI C++ ANSI C
ferror	Обнаруживает ошибки в потоке DOS UNIX Win16 #include<stdio.h> OS/2 Win32 int ferror(FILE *stream); ANSI C++ ANSI C
fflush	Очищает поток DOS UNIX Win16 #include<stdio.h> OS/2 Win32 int fflush(FILE *stream); ANSI C++ ANSI C
fgetc	Получает символ из потока DOS UNIX Win16 #include<stdio.h> OS/2 Win32 int fgetc(FILE *stream); ANSI C++ ANSI C
fgetchar	Получает символ из потока stdin DOS UNIX Win16 #include <stdio.h> OS/2 Win32 int fgetchar(void); ANSI C++ ANSI C
fgetpos	Получает текущий указатель файла DOS Win16 #include<stdio.h> OS/2 Win32 int fgetpos(FILE *stream, fpos_t *pos); ANSI C++ ANSI C
fgets	Получает строку из потока DOS UNIX Win16 #include<stdio.h> OS/2 Win32 char *fgets(char *s, int n, FILE *stream); ANSI C++ ANSI C
filelength	Получает размер файла в байтах DOS Win16 #include<io.h> OS/2 C++ Win32 long filelength(int handle);
fileno	Получает описатель файла DOS UNIX Win16 #include<stdio.h> OS/2 Win32 int fileno(FILE *stream);
findfirst	Выполняет поиск в каталоге диска DOS Win16 #include<dir.h> OS/2 Win32 int findfirst(const char *pathname, struct ffblk *ffblk, int attrib);
findnext	Продолжает поиск функции findfirst DOS Win16 #include<dir.h> OS/2 Win32 int findnext(struct ffblk *ffblk);
floor,floorl	Округляет в меньшую сторону floor #include <math.h> double floor(double x); DOS UNIX Win16 OS/2 Win32 ANSI C++ ANSI C ---***--- floorl #include <math.h> long double floorl(long double x); DOS Win16 OS/2 Win32
flushall	Очищает все потоки DOS UNIX Win16 #include <stdio.h> OS/2 C++ Win32 int flushall(void);
_fmemccpy	Смотpи memccpy.
_fmemchr	Смотpи memchr.
_fmemcmp	Смотpи memcmp.
_fmemcpy	Смотpи memcpy.
_fmemicmp	Смотpи memicmp.
_fmemset	Смотpи memset.
fmod, fmodl	Вычисляет x по модулю y, остаток от х/y fmod #include <math.h> double fmod(double x, double y); DOS UNIX Win16 OS/2 Win32 ANSI C++ ANSI C ---***--- fmodl #include <math.h> long double fmodl(long double x,long DOS Win16 double y); OS/2 Win32
fnmerge	Создает из составных частей полное имя файла DOS Win16 #include<dir.h> OS/2 Win32 void fnmerge(char *path, const char *drive, const char *dir, const char *name, const char *ext);
fnsplit	Расщепляет полное имя файла на компоненты DOS Win16 #include<dir.h> OS/2 Win32 void fnsplit(char *path, char *drive, char *dir, char *name, char *ext);
fopen	Открывает поток DOS UNIX Win16 #include<stdio.h> OS/2 Win32 FILE *fopen(const char *filename, ANSI C++ ANSI C const char *mode);
FP_OFF,FP_SEG	Получает смещение или сегмент с дальней адресацией DOS Win16 #include<dos.h> Win32 unsigned FP_OFF(void far *p); unsigned FP_SEG(void far *p);
_fpreset	Инициализирует заново математический пакет для работы с плавающей точкой DOS Win16 #include <float.h> OS/2 Win32 void _fpreset(void);
fprintf	Записывает форматированный вывод в поток DOS UNIX Win16 #include<stdio.h> OS/2 Win32 int fprintf(FILE *stream, ANSI C++ ANSI C const char *format[,аргумент,...]);
fputc	Выводит символ в поток DOS UNIX Win16 #include<stdio.h> OS/2 Win32 int fputc(int c, FILE *stream);
fputchar	Выводит символ в поток stdout DOS UNIX #include<stdio.h> OS/2 Win32 int fputchar(int c) ANSI C++
fputs	Выводит строку в поток DOS UNIX Win16 #include<stdio.h> OS/2 Win32 int fputs(const char *s, FILE *stream); ANSI C++ ANSI C
fread	Cчитывает данные из потока DOS UNIX Win16 #include<stdio.h> OS/2 Win32 size_t fread(void *ptr, size_t size, ANSI C++ ANSI C size_t n, FILE *stream);
free	Освобождает выделенный блок памяти DOS UNIX Win16 #include<stdlib.h> OS/2 Win32 void free(void *block); ANSI C++ ANSI C
freopen	Соединяет новый файл с открытым потоком DOS UNIX Win16 #include<stdio.h> OS/2 Win32 FILE *freopen(const char *filename, ANSI C++ ANSI C const char *mode, FILE *stream);
frexp,frexpl	Расщепляет число типа double на мантиссу и показатель frexp #include<math.h> double frexp(double x,int *exponent); DOS UNIX Win16 OS/2 Win32 ANSI C++ ANSI C ---***--- frexpl #include<math.h> long double frexpl(long double x, DOS UNIX Win16 int *exponent); OS/2 Win32
fscanf	Просматривает и форматирует ввод из потока DOS UNIX Win16 #include<stdio.h> OS/2 Win32 int fscanf(FILE *stream, ANSI C++ ANSI C const char *format[,address,...]);
fseek	Перемещает указатель файла по потоку DOS UNIX Win16 #include<stdio.h> OS/2 Win32 int fseek(FILE *stream,long int offset, ANSI C++ ANSI C int whence);
fsetpos	Позиционирует указатель файла потока DOS Win16 #include<stdio.h> OS/2 Win32 int fsetpos(FILE *stream, const fpos_t *pos); ANSI C++ ANSI C
_fsopen	Открывает поток с коллективным использованием файла DOS Win16 #include<stdio.h> OS/2 Win32 #include<share.h> FILE *_fsopen(const char *filename, const char *mode, int shflg);
fstat,stat	Получает информацию об открытом файле DOS UNIX Win16 #include<sys\stat.h> OS/2 Win32 int fstat(int handle, struct stat *statbuff); int stat(char *path,ctruct stat *statbuf);
_fstr*	Работа с потоками DOS Win16 См. описание функций strcat, strchr, OS/2 strcspn, strdup, stricmp, strlen, strlwr, strncat, strncmp, strncpy, strnicmp, strnset, strpbrk, strrchr, strrev, strset, strspn, strstr, strtok и strupr для версий с дальней адресацией.
ftell	Возвращает текущий указатель файла DOS UNIX Win16 #include<stdio.h> OS/2 Win32 long int ftell(FILE *stream) ANSI C++ ANSI C
ftime	Сохраняет текущее время в структуре timeb DOS UNIX Win16 #include<sys\timeb.h> OS/2 Win32 void ftime (struct timeb *buf);
_fullpath	Преобразует полное имя файла из относительного в абсолютное DOS Win16 OS/2 C++ Win32 #include<stdlib.h> char* _fullpath(char *buffer, const char *path, int buflen);
fwrite	Записывает в поток DOS UNIX Win16 #include<stdio.h> OS/2 Win32 size_t fwrite(const void *ptr, size_t size, ANSI C++ ANSI C size_t n, FILE *stream);

Назад | Содержание | Вперед

Справочник по работе с DOS

Ниже представлена информация, которая будет полезной при

разработке 16-разрядных приложений для работы в DOS.

Справочное руководство по ObjectWindows 2.0 для С++

В данном руководстве в алфавитном порядке перечислены классы

и структуры ObjectWindows с указанием соответствующих файлов-заголовков. Многие из характеристик данных классов иерархически

наследуются из базовых классов.

Примечание: Если класс имеет несколько конструкторов,

то описывается только наиболее общий из них.

Ссылки

Поскольку освоить работу со ссылками языка С++, начинающему

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

С++ позволяет передавать аргументы как по значению, так и по

ссылке. Типы ссылок С++ тесно связаны с типами указателей и служат для создания псевдонимов объектов и позволяют передачу аргументов функциям по ссылке.

Ссылки на данные и функции

В операторах asm вы можете использовать любой идентификатор

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

эти символы в соответствующие операнды ассемблера и добавляет к

именам идентификаторов символы подчеркивания.

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

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

в таблице идентификаторов Си. Имена регистров 80х86 из поиска

исключаются. Имена регистров можно задавать символами в верхнем

регистре.

При программировании вам не нужно заботиться о точных смещениях локальных переменных - использование имени переменной предусматривает корректные смещения. Однако, может оказаться необходимым включить в инструкции ассемблера WORD PTR, BYTE PTR или

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

типа FAR или LES необходимо переопределение DWORD PTR.

Стандартные объекты проверки допустимости

Стандартные классы проверки допустимости ObjectWindows автоматизируют проверку данных. ObjectWindows определяет в validate.h

6 классов проверки допустимости:

Класс Назначение

TValidator	Базовый класс, из которого создаются все другие производные классы.
TFilterValidator	Класс фильтра проверки допустимости.
TRangeValidator	Класс проверки допустимости по целочисленному диапазону.
TLookupValidator	Класс проверки по таблице.
TStringLookupValidator	Класс проверки допустимости строки.
TPXPictureValidator	Класс проверки допустимости по шаблону.

Стандартный файл определения модуля

Файл определения модуля не является строго обязательным для

создания выполняемой программы Windows с использованием Borland

C++. Если файл определения модуля не задан, по умолчанию принимается следующее:

CODE PRELOAD MOVEABLE DISCARDABLE

DATA PRELOAD MOVEABLE MULTIPLE (для прикладных про-

грамм) или

PRELOAD MOVEABLE SINGLE (для DLL)

HEAPSIZE 4096

STACKSIZE 5120 (для TLINK32 1048576)

Для замены утверждения EXETYPE компоновщик Borland C++ может

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

помощью IDE или компилятора командной строки.

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

IMPORTS определения модуля.

Для того, чтобы не нужно было указывать секцию EXPORTS, вы

можете использовать ключевое слово _exрort в определениях функций

экспорта в вашей исходной программе на языке Си или C++. Заметим,

однако, что если для экспорта функции используется _exрort, то

функция будет экспортироваться по имени, а не по перечислению

(перечисление обычно более эффективно).

Если вы хотите изменить стандартные атрибуты, вам необходим

файл определения модуля.

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

Некоторые аспекты языка Си стандарта ANSI не определены

ANSI достаточно подробно. В таких случаях каждая реализация компилятора Си может сама определять отношение к этим аспектам. Ниже

говорится о том, как эти зависящие от реализации стандарты определены фирмой Borland. Номера разделов соответствуют здесь публикации стандарта ANSI от февраля 1990 года, которая является самой

новой. Отметим, что между Си и С++ имеются различия, а данное

приложение относится исключительно к Си.

Как идентифицировать диагностические сообщения

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

Error или Warning, считается диагностическим в смысле, определяемом ANSI. Ниже приводятся параметры, необходимые для того, чтобы

обеспечивалась данная интерпретация:

Идентификация диагностических сообщений в C++

Опция Действие

-A	Разрешает только ключевые слова ANSI.
-C-	Запрещает вложенные комментарии.
-i32	Устанавливает минимум 32 значащих символа в идентификаторах.
-p-	Устанавливает использование соглашения о связях Си.
-w-	Выключает все предупреждения, кроме следующего.
-wbei	Включает предупреждение о несоответствии инициализаторов.
-wbig	Включает предупреждение о слишком большой константе.
-wcpt	Включает предупреждение о немобильных сравнениях указателей.
-wdcl	Включает предупреждение об объявлениях без типа или класса памяти.
-wdup	Включает предупреждение о дублирующихся неидентичных определениях макрокоманды.
-wext	Включает предупреждение о переменных, определенных сразу как external и static.
-wfdt	Включает предупреждение об определениях функции, использующих typedef
-wrpt	Включает предупреждение о немобильных преобразованиях указателей.
-wstu	Включает предупреждение о неопределенных структурах.
-wsus	Включает предупреждение о подозрительном преобразовании указателя.
-wvrt	Включает предупреждение о функции void, возвращающей значение.
-wucp	Включает предупреждение о смешанном использовании указателей signed и unsigned char.

<


Использование следующих параметров запрещено:

-ms!	Для моделей данных small SS и DS должны совпадать.
-mm!	Для моделей данных small SS и DS должны совпадать.
-mt!	Для моделей данных small SS и DS должны совпадать.
-zGxx	Имя группы BSS не может быть изменено.
-zSxx	Имя группы данных data не может быть изменено.

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

Семантика аргументов функции main



Когда программа выполняется в операционной системе DOS версий до 3.0, значение argv[0] представляет собой указатель на нулевой байт. Для версии DOS 3.0 и старше argv[0] указывает на имя программы.

Остальные строки argv указывают на каждый компонент аргументов командной строки DOS. Пробельные символы, разделяющие аргументы, удаляются, и каждая последовательность непрерывных непробельных символов рассматривается как отдельный аргумент. Строки

символов в кавычках рассматриваются обычным способом (как одна

строка, которая может содержать пробелы.)

Что считается интерактивным устройством

Это любое устройства, работающее как консоль.

Схема упорядочения набора символов времени выполнения

Схема упорядочения набора символов времени выполнения

использует знаковое ASCII-значение символа.

Элементы наборов символов - исходного и этапа выполнения

Наборы символов, исходный и времени выполнения, представляют

собой расширенный набор символов ASCII, поддерживаемый IBM PC. В

строковых литералах, символьных константах или комментариях, может находиться любой символ, кроме ^Z (Control-Z).

Многобайтовые символы

Многобайтовые символы в Borland C++ не поддерживаются.

Направление печати

Печать символов происходит слева-направо, в нормальном для

PC направлении.

Число бит в символе из набора воспринимаемых символов

Символ из набора символов этапа выполнения имеет длину 8

бит.

Число значащих начальных символов идентификатора

Значащими являются только первые 32 символа, хотя это значение может быть изменено при помощи параметров командной строки (l). И внешние, и внутренние символические имена имеют одинаковое



число значащих символов. (Число значащих символов в идентификаторах С++ не ограничено).

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

Компилятор обычно заставляет компоновщик делать различие

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

учет регистра, служит параметр командной строки (-l-c).

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

различных типов целых чисел

Тип Минимальное значение Максимальное значение

signed char	-128	127
unsigned char	0	255
signed short	-32768	32767
unsigned short	0	65535
signed int	-32768	32767
unsigned int	0	65535
signed long	-2147483648	2147483647
unsigned long	0	4294967295

Все типы char используют для хранения значения 8-битовый

байт.

Все типы char используют 1 8-битовый байт памяти.

Все типы short и int используют 2 байта (в 16-разрядной

программе).

Все типы short и int используют 4 байта (в 32-разрядной

программе).

Все типы long используют 4 байта.

Если задано выравнивание в памяти (-a), все объекты целых

типов, кроме char, выравниваются по границе четных байт. Если задан параметр -a4, результатом будет 4-байтовое выравнивание. Символьные типы не выравниваются никогда.

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

различных типов чисел с плавающей точкой

Для типов чисел с плавающей точкой Borland C++, допускаемых

сопроцессором Intel 8087 используются форматы плавающей точки

IEEE. Тип float использует 32-битовый формат действительных

чисел IEEE. Тип double использует 64-битовый формат

действительных чисел IEEE. Тип long double использует

80-битовый расширенный формат действительных чисел IEEE.

Соотношение между наборами символов - исходным и времени

выполнения

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

Текущее место действия, используемое для преобразования

многобайтовых символов в соответствующие широкие символы

для широкой символьной константы



Широкие символьные константы распознаются.

Значение целочисленной константы, которая содержит более

одного символа, или широкая символьная константа, которая содержит более одного многобайтового символа

Символьные константы могут содержать 1 или 2 символа. В случае двух символов первый символ занимает младший байт константы,

а второй - старший.

Результат преобразования целого в более короткий тип целого со знаком, либо результат преобразования целого без

знака в целое со знаком равной длины, если значение не

может быть представлено полностью

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

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

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

Целое число округляется до ближайшего представимого значения. Например, значение типа long (2^32-1) преобразуется в значение float 2^31. Разрешение направления округления производится по

стандартным арифметическим правилам IEEE.

Направление усечения или округления при преобразовании

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

меньшей точности представления.

Число округляется до ближайшего представимого значения. Разрешение направления округления производится по стандартным арифметическим правилам IEEE.

Результаты поразрядных операций для целых со знаком

Поразрядные операции выполняются для целых со знаком так

же, как и для соответствующих типов без знака. Знаковый бит

рассматривается как обычный бит данных. Результат затем

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

представленное как дополнение.

Что происходит, когда доступ к элементу объекта типа

объединения происходит при помощи элемента другого типа

Доступ разрешен и будет происходить к хранимым там битам.



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

хранимый элемент короче, чем элемент, используемый для доступа к

значению, то лишние биты будут иметь значения, то они сохранят

значения, которые они имели до записи в память более короткого

элемента.

Тип целого числа, предназначенного для хранения максимального размера массива

Для обычного массива это тип unsigned int, а для массивов в

случае модели данных huge это тип signed long.

Результат приведения типа указателя в целое и обратно

При преобразованиях между целыми и указателями одинаковых

размеров ни один бит не изменяется. При преобразовании более

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

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

указатели для преобразования в более длинный целый тип сначала

расширяются до типа указателя, который по длине равен данному

целому типу.

Знак остатка при целочисленном делении

Когда только один из операндов отрицателен, остаток также

будет отрицательным. Если ни один из операндов не отрицателен,

или оба отрицательны, остаток будет положительным.

Целый тип, необходимый для хранения разности между двумя

указателями на элементы одного и того же массива,

ptrdiff_t

Для ближних (near) указателей это тип signed int, а для указателей far или huge - это signed long. Тип ptrdiff_t зависит от

используемой модели памяти. Для малых моделей памяти это тип int,

а для больших моделей памяти - это тип long.

Результат сдвига вправо отрицательного целого типа со

знаком

Отрицательные значения со знаком при сдвиге

вправо расширяются по знаку.

Степень вероятности фактического размещения в регистрах

объектов со спецификатором класса памяти register



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

регистр динамические локальные переменные малого размера, но объявленные как register будут иметь приоритет. Для этого бывает

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

Рассматривается ли линейное битовое поле int как signed

int, или же как unsigned int

Линейные битовые поля int рассматриваются как имеющие тип

signed int.

Порядок распределения битового поля в int

Битовое поле распределяется в направлении от позиции младшего бита к позиции старшего бита (младший бит - самый правый).

Заполнение и выравнивание компонентов структур

По умолчанию заполнение структур символами-заполнителями не

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

по четным адресам смещения.

Может ли битовое поле пересекать границу блока памяти

Когда параметр выравнивания (-a) не запрашивается, битовое

поле может пересекать границу слова, но никогда не может занимать

более двух соседних байт.

Целый тип, которым представляются значения перечислимого типа

Если нумераторов столько, что хватает типа unsigned char, то

выбирается этот тип; в противном случае выбирается signed int.

Доступ к объекту типа volatile

Любая ссылка к объекту volatile приводит к доступу к этому

объекту. Приведет ли к доступу к объекту volatile доступ к смежным адресам памяти, зависит от конструктивной реализации памяти.

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

асинхронным прерываниям, так что доступ к соседним объектам не

оказывает влияния.



Максимальное число описателей, которые могут модифицировать арифметический тип, структуру или объединение

Специальных ограничений на число описателей нет. Число

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

уровне вложенности в набор блоков функции число описателей

уменьшается. На файловом уровне это число не менее 50.

Максимальное число case-вариантов в операторе switch

На число вариантов оператора switch специальных ограничений

нет. Если памяти достаточно, то компилятор обработает все.

Соответствует ли значение односимвольной константы в

выражении типа константы, управляющем условным включением, значению той же символьной константы в наборе

символов этапа выполнения; может ли такая символьная

константа принимать отрицательное значение

Все символьные константы, даже константы условных директив,

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

тип со знаком signed char (по умолчанию и при -K не запрашивается).

Метод поиска включаемых исходных файлов

В случае имен включаемых файлов, заданных в угловых скобках,

если каталоги включаемых файлов указаны в командной строке, то

поиск файлов производится в каждом из этих каталогов. Просмотр

каталогов включаемых файлов происходит в следующем порядке. Сначала берутся каталоги, заданные в командной строке, а затем указанные в TURBOC.CFG или BCC32.CFG. Если каталоги включаемых файлов не заданы, то поиск выполняется только в текущем каталоге.

Поддержка задания в кавычках имен включаемых исходных

файлов

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

Borland C++ будет выполнять поиск файла, как если бы его имя было

задано в угловых скобках.

Особенности последовательности символов в именах файлов

Символы обратной наклонной черты в именах включаемых файлов

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



или иная буква, игнорируются.

Определения __DATE__ и __TIME__ , когда они недоступны

Дата и время доступны всегда и используют системные дату и

время DOS.

Символ десятичной точки (для чисел с плавающей точкой).

Символом точки в десятичной записи чисел с плавающей

точкой является '.'.

Тип оператора sizeof, size_t

Тип size_t - unsigned int.

Константа - пустой указатель, в которую расширяется

макроопределение NULL

Для 16- разрядного приложения это int или long 0, в зависимости от модели памяти.

Для 32-разрядных приложений NULL расширяется в нулевое значение типа int или long (32-битовые числа со знаком).

Печатаемые диагностические сообщения и поведение при

завершении функции assert

Печатается диагностическое сообщение "Assertion failed:выражение, file имя_файла, line nn", где выражение - это выражение с

неудачно завершившейся функцией контроля особой ситуации,

имя_файла - это имя исходного файла, а nn - это номер строки, где

выполнялся контроль.

После вывода на дисплей данного диагностического сообщения

вызывается функция abort.

Определяемые реализацией аспекты проверки символов и

функции задания учета регистра

Отсутствуют, за исключением описанных в следующем пункте.

Наборы символов, проверяемые функциями isalnum,

isalpha, iscntrl, islower, isprint и isupper

Первые 128 ASCII-символов а режиме по умолчанию или все 256

символов.

Значения, возвращаемые математическими функциями при

ошибках, связанных с областью определения

IEEE NAN (не-число).

Устанавливают ли математические функции целочисленное

выражение errno в значение макрокоманды ERANGE в случае

ошибки потери значимости

Нет, только для других ошибок - области переполнения, сингулярности, переполнения и общей потери точности.

Происходит ли ошибка области определения, или возвращается ноль, когда функция fmod имеет второй аргумент,

равный нулю

Нет. fmod(x, 0) возвращает 0.

Набор сигналов функции signal

SIGABRT, SIGFPE, SIGILL, SIGINT, SIGSEGV, SIGTERM.

Семантика каждого сигнала, распознаваемого функцией



signal

См. описание функции signal в "Справочнике по библиотеке".

Обработка по умолчанию и обработка при загрузке программы каждого сигнала, распознаваемого функцией signal

См. описание функции signal в "Справочнике по библиотеке".

Блокирование сигнала, выполняемое если эквивалент

signal (sig,SIG_DFL); не выполнен перед вызовом обработчика сигналов

Эквивалент signal(sig,SID_DFL) выполняется всегда.

Будет ли отменена обработка сигнала по умолчанию при

получении сигнала SIGILL обработчиком, заданным функции

signal

Всегда выполняется эквивалент signal(sig,SIG_DGF).

Требуется ли в последней строке текстового потока оконечный символ новой строки

Нет, не требуется.

Появляются ли при чтении символы пробела, записанные в

текстовый поток непосредственно перед символом новой

строки

Да, появляются.

Число нулевых символов, которые могут быть добавлены к

данным, записываемым в двоичный поток

Не добавляются.

Устанавливается ли первоначально указатель позиции файла потока в режиме добавления (append) в начало или в конец файла

Указатель позиции файла для потока в режиме добавления

первоначально помещается в начало файла. Перед каждой операцией

записи он сбрасывается в конец файла.

Вызывает ли запись в текстовый поток усечение связанного с потоком файла за данной позицией

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

поведение.

Характеристики буферизации файла

Файл может иметь полную буферизацию, строчную буферизацию

или не иметь таковой. Если файл буферизован, то перед открытием

файла по умолчанию создается буфер с размером 512 байт.

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

Да, существуют.

Может ли один и тот же файл быть открыт неоднократно

Да, может.

Действие функции remove на открытый файл

Никакой специальной проверки, является ли файл открытым, не

выполняется. Ответственность лежит на программисте.



Что произойдет, если файл с новым именем уже существовал перед вызовом rename

rename вернет значение -1, а errno будет установлена в значение EEXIST.

Вывод в случае преобразования %p в fprintf

В случае ближних моделей данных это четыре шестнадцатиричных

цифры (XXXX). В случае дальних моделей данных это четыре шестнадцатиричных цифры, двоеточие и еще четыре шестнадцатиричных

цифры (XXXX:XXXX). (Для 16-разрядных программ.)

Восемь шестнадцатиричных цифр (ХХХХХХХХ) (для 32-разрядных

программ).

Ввод в случае преобразования %p в fscanf

См. в предыдущем пункте.

Интерпретация символа дефис (-), который не является ни

первым, ни последним символом в списке сканирования в

случае преобразования %[ в fscanf

См. описание fscanf в "Справочнике по библиотеке".

Значение, в которое устанавливается макрокоманда errno

функциями fgetpos или ftell при неудачном завершении

EBADF - Неверный номер файла.

Сообщения, генерируемые функцией perror

Статические библиотеки ObjectWindows

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

операционной системе они доступны. Эти файлы находятся в вашем

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

находятся в каталоге SOURCE\OWL), используя параметры -DDIAGS и

-DMODEL.

Имя файла Приложение Использование

OWLWS.LIB	Win16	16-разрядная малая модель
OWLWM.LIB	Win16	16-разрядная средняя модель
OWLWL.LIB	Win16	16-разрядная большая модель
OWLDWS.LIB	Win16	16-разрядная диагностическая малая модель
OWLDWM.LIB	Win16	16-разрядная диагностическая средняя модель
OWLDWL.LIB	Win16	16-разрядная диагностическая большая модель
OWLWF.LIB	Win32s, Win32	32-разрядная библиотека
OWLDWF.LIB	Win32s, Win32	32-разрядная диагностическая библиотека
OWLWI.LIB	Win16	16-разрядная библиотека импорта для OWL200.DLL
OWLDWI.LIB	Win16	16-разрядная библиотека импорта для OWL200D.DLL
OWLWFI.LIB	Win32s, Win32	32-разрядная библиотека импорта для OWL200F.DLL
OWLDWFI.LIB	Win32s, Win32	16-разрядная библиотека импорта для OWL200DF.DLL
OWL200.DLL	Win16	16-разрядная динамическая библиотека
OWL200F.DLL	Win32	32-разрядная динамическая библиотека
OWL200D.DLL	Win16	Диагностическая версия 16-разрядной динамической библиотеки
OWL200DF.DLL	Win32	Диагностическая версия 32-разрядной динамической библиотеки

Статические данные в 16-битовых DLL

С помощью функций DLL все приложения, использующие DLL, могут обращаться к глобальным данным DLL. В 16-разрядных DLL функция будет использовать одни и те же данные, независимо от вызывающего ее приложения (в 32-разрядных DLL данные являются частными

данными процесса). Если вы ходите защитить в 16-разрядной DLL

глобальные данные и ограничить их использование единственным приложением, эту защиту нужно написать самостоятельно. Сама DLL не

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

и работать с ними вручную. Статические данные в 16-разрядной DLL

являются глобальными для всех вызывающих приложений.

Статические управляющие элементы

Статические управляющие элементы обычно представляют собой

неизменяемые блоки текста или простую графику. Пользователь не

взаимодействует с такими элементами, хотя ваше приложение может

изменять его текст. Примеры вы можете найти в подкаталоге EXAPMLES\OWL\OWLAPI\STATIC.

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

им манипулировать, идентификатор управляющего элемента может не

указываться.

Конструктор TStatic воспринимает обычно стандартных 7 параметров объектов управляющих элементов и два специальных параметра

- текстовую строку статического управляющего элемента и ее максимальную длину (включая завершающий 0). TStatic получает заданные

по умолчанию стили управляющего элемента, добавляет SS_LEFT (для

выравнивания текста влево) и удаляет стиль WS_TABSTOP (чтобы предотвратить перемещение на данный элемент по клавише Tab). Чтобы

изменить стиль, модифицируйте в конструкторе объекта статического

управляющего элемента Attr.Style.

TStatic имеет две функции-элемента для изменения текста статического управляющего элемента: SetText задает текст элемента в

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

Функция TStatic::GetTextLen возвращает длину текста статического управляющего элемента. Чтобы получить сам текст, используйте TStatic::GetText.

_Stklen (dos.h)

Данная переменная содержит размер стека и имеет следующий

синтаксис:

extern unsigned _stklen;

Переменная _stklen определяет размер стека для 6 моделей памяти. Минимально допустимый размер стека - 128 слов. По умолчанию назначается размер 4К.

В моделях данных small и medium сегмент данных вычисляется

следующим образом:

сегмент данных [small, medium] = глобальные данных +

динамически распределяемая область + стек

где размер динамически распределяемой области можно настроить с

помощью _heaplen.

В модели tiny все (включая код) находится в одном и том же

сегменте, поэтому размер сегмента данных вычисляется следующим

образом (с учетом 256 байт для PSP):

сегмент данных [tiny] = 256 + глобальные данные +

динамически распределяемая область + стек

В моделях compact и large ближней динамически распределяемой

области нет, и стек имеет собственный сегмент, поэтому сегмент

данных вычисляется так:

сегмент данных [compact, large] = глобальные данные

В модели huge стек находится в отдельном сегменте, и каждый

модуль имеет собственный сегмент данных.

Назад | Содержание | Вперед

Странные вызовы конструктора

Обратите внимание на забавные вызовы конструктора базового

класса - использование операции ':' после заголовка функции, и перед

телом функции. Конструктор порожденного класса вызывает конструктор

базового класса, используя синтаксис вызова функции.

circle::circle(double x, double y, double r)

: shape(x,y) < Заметьте как конструктор circle вызывает

конструктор shape с начальной установкой

{

radius = r;

}

Строковые инструкции

Помимо кодов операций, приведенных выше, возможно использование следующих строковых команд, как в исходном виде, так и с

префиксами циклического выполнения.

Строковые инструкции BASM

cmps insw movsb outsw stos

smpsb lods movsw scas stosb

smpsw lodsb scasb stosw

lodsw outsb scasw

insb movs

Структура TChooseColorDialog::TData (chooseco.h)

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

Структура TDialogAttr

Используется для записи атрибутов создания TDialog.

Структура TEdgeConstraint (layoutco.h)

Эта структура добавляет функции-элементы и устанавливает ограничения границ (но не размера). Она всегда помещает ваше окно

на один элемент изображения выше других окон и затем добавляет

поля.

Структура TEdgeOfSizeConstraint (layoutco.h)

Эта производная от TEdgeConstraint структура представляет

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

Структура TFindReplaceDialog::TData (findrepl.h)

Эта структура определяет информацию, необходимую для инициализации диалогового окна TFindReplace.

Структура TLayoutConstraint (layoutco.h)

Эта структура, определяющие ограничения разметки (схемы) окна. Ограничения схемы окна задаются в виде соотношения между шириной и высотой или размером одного окна и краями или размером

другого (одного из братских или родительского окна). Если между

окнами существует связь родительское-дочернее, то размеры дочерних окон зависят от родительского окна. Высота/ширина окна может

зависеть от его противоположного измерения (ширины/высоты).

Структура TListBoxData (listbox.h)

Эта структура используется для передачи содержимого блока

списка.

Структура TOpenSaveDialog::TData (opensave.h)

Содержит информацию о выборе открытия или сохранения файла.

Структура TPrintDialog::TData (printdia.h)

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

Структура TScrollBarStruct (scrollba.h)

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

Структура TWindowAttr (window.h)

Содержит атрибуты TWindow, устанавливаемые при построении.

Ваша программа управляет созданием окна, передавая эти значения

подпрограммам создания TWindow.

Style Sheet

Style Sheet - это набор параметров для построения проекта.

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

Их значения сохраняются в Style Sheet, а по умолчанию проекты используют Style Sheet с именем "Default Project Options". Если все

компоненты проекта используют одни и те же параметры, вы можете

задать их с помощью диалогового окна Options Project (отредактировав тем самым заданную по умолчанию Style Sheet).

При построении проекта администратор проекта используется

параметры заданные в Style Sheet и Local Override. Если проект

еще не имеет Style Sheet, то используется набор параметров родительского объекта. Пример использования Style Sheet вы можете увидеть в STYLESHT.IDE в каталоге \EXAMPLES\IDE\STYLESHT.

Администратор проекта содержит несколько наборов Style Sheet, которые вы можете использовать, но можно создать для узла и

собственный набор Style Sheet:

Выделите узел и щелкните на нем правой кнопкой "мыши".

Выберите Edit node attributes.

Выберите в блоке списка Style Sheet и щелкните "мышью" на

OK.

Для создания нового комплекта Style Sheet вы можете также

щелкнуть "мышью" на кнопке Style.

Связь документов с классами отображаемых элементов

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

отображаемого элемента) и созданием экземпляра шаблона из этого

определенного класса.

После определения шаблона класса вы можете создать любое

число его экземпляров. Каждый шаблон связывает единственный класс

документа и класс отображаемого элемента. Каждый шаблон имеет

имя, заданное по умолчанию расширение имени файла, каталог, флаги

и фильтры файла. Таким образом, вы можете создать единственный

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

Связь интерфейсных объектов с управляющими элементами

Так как диалоговый блок создается из ресурса, вам не нужно

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

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

Предусмотреть специальную реакцию на сообщения. Например,

вы можете отредактировать управляющий элемент или изменять

стиль командной кнопки при ее "нажатии".

Использовать для манипулирования управляющим элементом

функции-элементы и элементы данных. Это легче и больше

ориентировано на работу с объектами, чем использование сообщений.

Связывание функций

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

Вызовы функции: Описания функций:

func_down(); > my_first_metod();

my_metod(); > func_down();

my_first_metod(); > my_metod();

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

> описание функции

int my_first_metod(int a, int b)

{

return a + 2*b;

}

.......................

k = my_first_metod(12, 24);

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

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

функции элемента не связывается с обращением к нему до того момента,

пока обращение не произойдет фактически, то есть во время выполнения

программы.

Так в библиотеке Turbo Vision любой объект, порожденный от

TView, должен быть способен к самоизображению в любой момент времени.

Объект TView определяет виртуальную функцию элемент draw, и каждый

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

Это имеет большое значение, т.к. часто отображаемый объект может быть

закрыт другим отображаемым объектом (или на него может быть наложен

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

File Window

Next F6 Demo Window 3

Zoom F5 Demo Window 7

Demo Window 8

Demo Window 1

Demo Window 4

Demo Window 6 Window 2

[*] Demo Window 9 [+]

Alt-X Exit F4 New Alt-F3 Close

Рисунок: программа, написанная с помощью библиотеки Turbo Vision

с множеством открытых окон.

В такой динамической системе нельзя заранее предсказать, сколько

отображаемых объектов будет на экране, каких они будут типов (окно,

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

ранее связывание, вся информация о количестве, координатах и типах

отображаемых объектов хранится в основной программе. Все возможные

действия над ними тоже должны быть предусмотрены в этой программе.

Таким образом, программе приходится отслеживать очень многое, она

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

скорректировать программу во всех тех местах, где определяется, какие

подпрограммы подлежат вызову.

Каким же образом можно улучшить положение с помощью позднего

связывания? Рассмотрим случай, когда один отображаемый объект, например, - окно, частично перекрывает другое. Если "верхнее" окно будет

передвинуто или закрыто, то нижнее следует перерисовать для восстановления ранее перекрытой части.

Так как меню окно перерисовывается иначе, чем диалоговая панель

или окно, то каждый объект в отображаемой иерархии должен знать, как

перерисовать себя. В библиотеке Turbo Vision этим занимается функция

элемент draw, имеющийся в каждом объекте-потомке класса TView. Следовательно, если требуется перерисовать объект, то программе не нужно

анализировать, к какому типу отображаемого объекта он относится (как

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

Не смотря на то, что программисты, для достижения полиморфизма

предпочитают использовать позднее связывание, но его можно достичь и

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

Связывание значения с функциями-элементами

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

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

V V

void clock::tick(int sec) Динамическое

^ связывание

{ с функциями

val += sec; элементами

}

V

clock big_ben; // Объявление объекта

^

v v v

big_ben.tick(25);

Позднее (динамическое) связывание происходит во время выполнения

программы. Его можно достигнуть путем использования наследования и

виртуальных функций элементов. Вы можете также использовать указатели

функций. Однако, с виртуальными функциями элементами, все эти опасные

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

Кроме объектов, динамически размещаемых в памяти Турбо и Borland

C++ позволяют вводить статические объекты. Статические объекты размещаются в сегменте данных на этапе компиляции вместе с другими статическими переменными. Это улучшает эффективность использования памяти

и быстродействие по сравнению с динамически размещаемыми объектами.

Свопинг

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

В обоих случаях есть две возможности: программа управления оверлеями может либо обнаруживать наличие дополнительной или расширенной памяти самостоятельно и затем брать на себя управление этой памятью, либо использовать уже обнаруженную и распределенную часть такой памяти. В случае расширенной памяти обнаружение памяти не во всех случаях выполняется удачно, поскольку многие программы кэширования памяти и программы организации виртуального диска могут использовать эту память, не делая об этом никаких отметок. Чтобы избежать этих проблем, вы должны сообщить программе управления оверлеями начальный адрес расширенной памяти и какой участок ее можно безопасно использовать. Borland С++ предусматривает две функции, которые позволяют вам инициализировать расширенную и дополнительную память - _OvrInitEms и _OvrInitExt.

- T -

Table limit exceeded

Сообщение об ошибке утилиты TLINK

(превышен размер таблицы)

Переполнена одна из внутренних таблиц компоновщика. Обычно

это означает, что компонуемые программы превышают возможности

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

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

Target index of FIXUP is 0 in module модуль

Сообщение об ошибке утилиты TLINK

(целевой индекс FIXUP в модуле равен 0)

Ошибка транслятора.

Template argument must be a constant expression

Сообщение об ошибке этапа компиляции

(аргумент шаблона должен быть выражением-константой)

Нетипизированный фактический аргумент шаблона класса должен

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

в себя целочисленные выражения-константы, адреса объектов или

функций с внешней компоновкой элементов.

Template class nesting too deep: 'class'

Сообщение об ошибке этапа компиляции

(слишком глубокая вложенность шаблона класса)

Компилятор накладывает определенные ограничения на уровень

вложенности шаблонов классов, который можно обойти обычно только

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

вложенности превышен, компилятор выводит данное сообщение об

ошибке для всех вложенных шаблонов классов, что обычно позволяет

легко выявить место рекурсии. Это всегда следует за фатальной

ошибкой Out of memory (Нет памяти).

Например, рассмотрим следующий набор шаблонов классов:

template<class T> class A

{

friend class B<T*>;

};

template<class T> class B

{

friend class A<T*>;

};

A<int> x;

Что приведет к выводу следующих сообщений:

Error: Template class nesting too deep: 'B<int******>'

Error: Template class nesting too deep: 'B<int****>'

Error: Template class nesting too deep: 'B<int***>'

Error: Template class nesting too deep: 'B<int**>'

Error: Template class nesting too deep: 'B<int*>'

Error: Template class nesting too deep: 'B<int>'

Fatal: Out of memory

Template function argument аргумент not used in argument types


Сообщение об ошибке этапа компиляции

(аргумент шаблона функции не используется в типе аргумента)

Данный аргумент не использован в списке аргументов функции.

В списке аргументов шаблона функции должны использоваться все ее

формальные аргументы. В противном случае невозможно сгенерировать

экземпляр шаблона функции на основе типов фактических аргументов.

Template functions may only have type-arguments


Сообщение об ошибке этапа компиляции

(в шаблонах функций могут быть только аргументы-типы)

В шаблоне функции описывается аргумент, отличный от типа. В

шаблоне функции это не допускается, так как нет способа задать

значение при ее вызове.

Templates can only be declared at file level


Сообщение об ошибке этапа компиляции

(шаблоны могут описываться только на уровне файла)

Объявление в описании шаблона должно задавать тип класса или

функцию.

Templates must be clases or functions


Сообщение об ошибке этапа компиляции

(шаблоны должны быть классами или функциями)

Описание шаблона должны быть классом или функцией.

Temporary used to initialize идентификатор



Предупреждение этапа компиляции

(Для инициализации идентификатора использовалась временная

переменная)

См. следующее сообщение.

Temporary used for parameter номер in call to функция



Предупреждение этапа компиляции

(При вызове функции для параметра номер использовалась временная переменная) См. следующее сообщение.

Temporary used for parameter параметр in call to функция



Предупреждение этапа компиляции

(При вызове функции для параметра параметр использовалась временная переменная) См. следующее сообщение.

Temporary used for parameter номер



Предупреждение этапа компиляции (Для параметра номер использовалась временная переменная) См. следующее сообщение.

Temporary used for parameter параметр

Предупреждение этапа компиляции (Для параметра параметр использовалась временная переменная)



В С++ переменной или параметру типа ссылки должна присваиваться ссылка на объект этого же типа. Если типы не совпадают,

фактическое значение присваивается временной переменной нужного

типа, а адрес этой временной переменной присваивается переменной

или параметру типа ссылки. Предупреждение означает, что данная

переменная или параметр типа ссылки относится не к тому, что вы

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

Например, функция f требует ссылку на int, а c имеет тип char:

f (int&);

char c;

f (c);

Вместо вызова f с адресом c компилятор генерирует код, эквивалентный следующему исходному коду С++:

int X = c, f (X);

Terminated by user


Сообщение об ошибке утилиты TLINK

(прервано пользователем)

Вы прервали работу компоновщика.

The '...' handler must be last


Сообщение об ошибке этапа компиляции

(обработчик '...' должен быть последним)

Если в списке обработчиков присутствует '...', то это должен

быть последний обработчик в списке.

The combinations '+*' or '*+' not allowed


Сообщение об ошибке утилиты TLIB

(комбинации '+*' или '*+' не допускаются)

Не допускается добавлять и извлекать модуль из библиотеки за

одно действие. Возможно требуется действие '+-'.

The constructor конструктор is not allowed


Сообщение об ошибке этапа компиляции

(конструктор недопустим)

Конструкторы вида X:: (X) недопустимы. Правильный способ записи конструктора: X:: (const X&)

'this' can only be used within a member function

Сообщение об ошибке этапа компиляции

('this' можно использовать только в функции-элементе)

В С++ this - это зарезервированное слово, которое можно использовать только в пределах функций-элементов класса.

This initialization is only partly bracketed



Предупреждение этапа компиляции

(данная инициализация заключена в скобки только частично)

При инициализации структуры скобки могут использоваться,

чтобы отметить инициализацию каждого элемента структуры. Если сам

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



компилятор выводит данное предупреждение.

Too few arguments in template class name шаблон


Сообщение об ошибке этапа компиляции

(слишком мало аргументов в шаблоне класса)

В имени шаблона класса пропущены фактические значения некоторых формальных параметров.

Too few parameters in call


Сообщение об ошибке этапа компиляции

(слишком мало параметров в вызове)

Вызов функции с прототипом (через указатель) имеет слишком

мало аргументов. Прототипы требуют точного задания всех параметров.

Too few parameters in call to функция


Сообщение об ошибке этапа компиляции

(слишком мало параметров в вызове функции)

Вызов названной функции (объявленной с использованием прототипа) имеет слишком мало аргументов.

Too many commas on command-line


Сообщение об ошибке этапа компиляции

(слишком много запятых в командной строке)

В командной строке найдена недопустимая запись.

Too many decimal points


Сообщение об ошибке этапа компиляции

(слишком много десятичных точек)

Компилятор встретил константу с плавающей точкой, в которой

находится более одной десятичной точки.

Too many default cases


Сообщение об ошибке этапа компиляции

(слишком много операторов default)

Компилятор встретил более одного оператора default в одной

конструкции switch.

Too many error or warning messages


Сообщение об ошибке этапа компиляции

(слишком много сообщений об ошибке или предупреждений)

Компилятор может зарегистрировать до 255 ошибок или предупреждений, а потом остановит свою работу.

Too many error or warning messages


Сообщение об ошибке утилиты TLINK

(слишком много ошибок или предупреждений)

Число выводимых компилятором сообщений ограничивается определенным пределом. Данное сообщение показывает, что компоновщик

достиг этого предела.

Too many errors


Сообщение об ошибке утилиты TLINK

(слишком много ошибок)

Компилятор обнаружил больше ошибок, чем допускается параметром -E.

Too many exponents


Сообщение об ошибке этапа компиляции

(слишком много показателей степени)

Компилятор встретил в константе с плавающей точкой более одного показателя степени.



Too many initializers


Сообщение об ошибке этапа компиляции

(слишком много инициализаторов)

Компилятор встретил больше инициализаторов, чем это допускается инициализируемым объявлением.

Too many LNAMEs


Сообщение об ошибке утилиты TLINK

(слишком много LNAME)

В одном объектном модуле LNAME не может иметь более 256 LNAME.

Too many rules for target цель


Сообщение об ошибке утилиты MAKE

(слишком много правил для цели)

При построении цели MAKE не может определить, какому правилу

следовать.

Too many storage classes in declaration


Сообщение об ошибке этапа компиляции

(в объявлении слишком много классов памяти)

В объявлении должно указываться не больше одного класса памяти.

Too many suffixes in .SUFFIXES list


Сообщение об ошибке утилиты MAKE

(слишком много суффиксов в списке .SUFFIXES)

В списке суффиксов вы превысили максимально допустимое ограничение - 255.

Too many types in declaration


Сообщение об ошибке этапа компиляции

(в объявлении слишком много типов)

Объявление может содержать не более одного из следующих базовых типов: char, int, float, double, struct, union, enum или

typedef-имя.

Too much global data defined in file


Сообщение об ошибке этапа компиляции

(в файле объявлено слишком много глобальных данных)

Сумма объявленных глобальных данных превысила по размеру

64К. Проверьте объявления массивов, которые могут быть причиной

выхода за пределы памяти. Либо реорганизуйте программу, либо, если все объявления вам нужны, используйте переменные far.

Trying to derive a far class from a huge base база


Сообщение об ошибке этапа компиляции

(попытка объявить класс far, производный от базового класса

huge)

Если класс объявлен (или имеет по умолчанию) тип huge, то

все классы, производные от него, также должны быть huge.

Trying to derive a far class from a near base база


Сообщение об ошибке этапа компиляции

(Попытка объявить класс far, производный от базового класса

near). Если класс объявлен (или имеет по умолчанию) тип near, то

все классы, производные от него, также должны быть near.



Trying to derive a near class from a far base база


Сообщение об ошибке этапа компиляции

( попытка объявить производный класс near от базового класса

far). Если класс объявлен (или имеет по умолчанию) тип far, то все

классы, производные от него, также должны быть far.

Trying to derive a huge class from a near base база


Сообщение об ошибке этапа компиляции

(попытка объявить производный класс huge от базового класса

near). Если класс объявлен (или имеет по умолчанию) тип near, то

все классы, производные от него, также должны быть near.

Trying to derive a near class from the huge base база


Сообщение об ошибке этапа компиляции: (попытка объявить производный класс near от базового класса

huge). Если класс объявлен (или имеет по умолчанию) тип huge, то

все классы, производные от него, также должны быть huge.

Two consecutive dots


Сообщение об ошибке этапа компиляции

(две последовательно расположенные точки)

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

(.), то две последовательные точки в программе на языке Си недопустимы.

Two operands must evaluate to the same type


Сообщение об ошибке этапа компиляции

(два операнда должны давать при вычислении один и тот же

тип)

Типы выражений по обеим сторонам двоеточия в условной операции (?:) должны быть одинаковыми, за исключением тех, что позволяют взаимные преобразования типа - char в int, float в double

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

типы. Это может быть либо ошибкой, либо вам нужно просто выполнить приведение типов участвующих в выражении операндов.

Type тип is not a defined class with virtual functions


Сообщение об ошибке этапа компиляции

(данный тип не является определенным типом для виртуальных

функций)

Dynamic_cast использовалось с указателем на класс, который

не определен или не имеет виртуальных функций.

Примечание относительно сообщений Type mismatch: При компиляции программ в С++ перед следующими сообщениями всегда выводится другое сообщение, поясняющее точную причину несоответствия типов. Обычно это "Cannot convert 'тип_1' to 'тип_2'. Но могут быть



и другие причины.

Type mismatch in default argument value


Сообщение об ошибке этапа компиляции

(несоответствие типа в используемом по умолчанию значении параметра). См. следующее сообщение.

Type mismatch in default value for parameter параметр


Сообщение об ошибке этапа компиляции

(несоответствие типа в используемом по умолчанию значении

параметра параметр)

Используемое по умолчанию значение параметра не может быть

преобразовано к типу параметра. Первое сообщение выводится, когда

для параметра не задано имя.

Type mismatch in parameter номер


Сообщение об ошибке этапа компиляции

(несоответствие типа в параметре номер)

Вызванная через указатель функция была объявлена с прототипом; данный параметр с указанным номером (отсчитывая слева направо от 1) не может преобразоваться к объявленному типу параметра.

Type mismatch in parameter параметр


Сообщение об ошибке этапа компиляции

(несоответствие типа в параметре параметр)

Вызванная через указатель функция была объявлена с прототипом; указанный же параметр не может быть преобразован к объявленному типу параметра. См. выше сообщения о несоответствии типов.

Type mismatch in parameter номер in call to функция


Сообщение об ошибке этапа компиляции

(несоответствие типа параметра номер в вызове функции)

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

Type mismatch in parameter параметр in call to функция


Сообщение об ошибке этапа компиляции

(несоответствие типа параметра в вызове функции функция)

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

типу параметра. См. сообщение Type mismatch in parameter параметр

.

Type mismatch in parameter параметр in template class name шаблон

Сообщение об ошибке этапа компиляции

(несоответствие типа в параметре в имени шаблона класса). См. следующее сообщение.



Type mismatch in parameter число in template class name шаблон


Сообщение об ошибке этапа компиляции

(несоответствие типа в параметре в имени шаблона класса)

Фактической значение аргумента шаблона для данного параметра

не соответствует в точности типу формального параметра шаблона.

См. выше сообщения о несоответствии типов.

Type mismatch in redeclaration of идентификатор


Сообщение об ошибке этапа компиляции

(несоответствие типа в повторном описании идентификатора)

В вашем исходном файле переменная переописывается с другим

типом, нежели тот, с которым она была объявлена первоначально.

Это может произойти, если функция вызывается и затем объявляется

с типом возврата, отличным от целочисленного. В этом случае вы

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

Type name expected


Сообщение об ошибке этапа компиляции

(требуется имя типа)

Произошла одна из следующих ошибок:

в описании файлового уровня или поля структуры не задан

класс памяти и имя типа;

в описании typedef не указан тип для имени;

в описании деструктора класса С++ имя деструктора не является именем типа (это должно быть то же имя, что и имя

класса);

при указании имени базового класса С++ имя не является

именем базового класса.

Type qualifier идентификатор must be a struct or class name


Сообщение об ошибке этапа компиляции

(квалификатор идентификатор типа должен быть структурой или

именем класса)

Квалификатор С++ в конструкторе квалификатор::идентификатор

не является именем структуры или класса.

Таблица реакции на сообщения

После создания нового производного класса вам нужно построить для него таблицу реакции. Таблица реакции для данного класса

выглядит как обычная таблица реакции. Вам нужно обрабатывать в

ней те же командные сообщения, как и обычно. Единственным добавлением является макрокоманда EV_VBXEVENTNAME для обработки нового

класса сообщений от управляющих элементов VBX. Эта макрокоманда

имеет три параметра:

Идентификатор управляющего элемента.

Строку, идентифицирующую имя события. Эта строка зависит

от управляющего элемента и может быть одним из стандартных

имен событий VBX или специальным именем события.

EvHandler - функцию-обработчик для данного события и управляющего элемента.

Текстовое окно Get Info

Вы можете выбрать команду File Get Info для анализа использования памяти и определения того, почему получил управление отладчик. Эта и другая информация отображается в текстовом блоке, который удаляется с экрана при нажатии клавиши Enter, пробела или

Esc. В этом окне отображается следующая информация, в зависимости

от того, отлаживаетесь ли вы в DOS, или в Windows.

Если вы отлаживаете программу для DOS, то в блоке System

Information будет выведена следующая информация:

имя отлаживаемой вами программы;

описание причины остановки программы;

объемы памяти, используемой DOS, отладчиком и вашей програм мой;

версия DOS или Windows, под управлением которой вы работае те;

текущая дата и время.

TDW дает вам следующую информацию о глобальной памяти:

Mode (режим)		Режимами памяти могут быть: Large-frame EMS (EMS-память с большим размером страничного блока), Small-frame EMS (EMS-память с малым размером страничного блока), или non-EMS (дополнительная память).
Banked (банкируемая)		Объем памяти в килобайтах выше линии банка EMS (которая может быть откачана в расширенную память, если ее использует система).
Not Banked (не банкируемая)		Объем памяти в килобайтах ниже линии банка EMS (которая не может быть откачана в расширенную память).
Largest (наибольший)		Наибольший непрерывный блок памяти в килобайтах.
Symbols (идентификаторы)		Объем оперативной памяти, используемый для загрузки таблицы идентификаторов программы.

Кроме перечисленной выше информации окно Windows System Information для Windows NT содержит также следующую информацию: Memory Load Factor (процент используемой оперативной памяти), Physical (доступный и общий объем системной памяти), Page file (размер текущего страничного файла и максимальный размер) и Virtual

(общая и доступная виртуальная память).

Текстовые и графические окна

Borland C++ обеспечивает функции для создания окон и управления ими в текстовом режиме (и графических окон в графическом

режиме). Если вы не знакомы с текстовыми и графическими окнами,

ознакомьтесь со следующим кратким их изложением. Функции Borland

C++, позволяющие управлять текстовыми и графическими окнами, описаны ниже в разделах "Программирование в текстовом режиме" и

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

Окно представляет собой прямоугольную область, определенную

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

По умолчанию размер окна равен всему экрану. При помощи

функции window ваша программа может изменить данное использование

по умолчанию полноэкранного текстового окна на текстовое окно,

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

В графическом режиме вы также можете определить некоторую

прямоугольную область экрана PC. Эта область называется графическим окном или областью просмотра (viewport). Когда ваша графическая программа выполняет вывод рисунков и т.д., графическое окно

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

окно можно через экранные координаты, вызвав функцию setviewport.

За исключением функций определения текстовых и графических

окон, все остальные функции, как текстового, так и графического

режимов, даются в локальных координатах активного текстового или

графического окна, а не в абсолютных экранных координатах. При

этом верхний левый угол текстового окна будет представлять собой

начало координат (1,1). В графическом режиме начало координат

графического окна будет равно (0,0).

Текстовый вывод в графическом режиме

Ниже приводится краткое описание функций текстового вывода в

графическом режиме:

Функция Описание

gettextsettings	Возвращает текущий текстовый шрифт, направление, размер и выравнивание.
outtext	Посылает строку на экран в текущую позицию (CP).
outtextxy	Посылает текст на экран в заданную позицию.
registerbgifont	Регистрирует компонуемый или определяемый пользователем шрифт.
settextjustify	Устанавливает значения выравнивания текста, используемые функциями outtext и outtextxy.
settextstyle	Устанавливает шрифт, тип и коэффициент увеличения текущего текста.
setusercharsize	Устанавливает соотношение между высотой и шириной штриховых шрифтов.
textheight	Возвращает высоту строки в элементах изображения.
textwidth	Возвращает ширину строки в элементах изображения.

Графическая библиотека включает в себя матричный шрифт 8х8 и

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

В матричном битовом шрифте каждый символ определяется как

матрица элементов изображения.

В векторном шрифте каждый символ определяется как последовательность векторов, сообщающих графической системе, как

создается данный символ.

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

Поскольку векторный шрифт определяется как последовательность

векторов, при увеличении размера он сохранит хорошее разрешение и

качество изображения. И напротив, когда вы увеличиваете битовый

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

вполне удовлетворителен, однако для больших размеров вам лучше

выбрать векторный шрифт.

В графике текст выводится функциями outtext или outtextxy, а

управление его выравниванием (относительно текущей позиции) выполняет функция settextjustify. При помощи функции settextstyle

вы должны выбрать символьный шрифт, направление его размещения

(горизонтальное или вертикальное) и размер (масштаб). Узнать текущие установки вывода текстов можно при помощи функции

gettextsettings, которая возвращает текущий текстовый шрифт, выравнивание, увеличение и направление в структуре textsettings.

Функция setusercharsize позволяет модифицировать ширину и высоту

векторных шрифтов.

Если средство отсечения изображения включено, то выводимые

функциями outtext и outtextxy текстовые строки будут отсекаться

по границам графического окна. Если отсечение отключено, то тексты с матричным шрифтом, символы которых не помещаются целиком в

окне, отбрасываются полностью. В случае же векторных шрифтов не

поместившиеся тексты просто отсекаются по границе окна.

Для того, чтобы определить экранный размер данной текстовой

строки, вызовите функцию textheight (которая измеряет высоту

текста в элементах изображения) и textwidth (измеряющую его ширину в элементах изображения).

По умолчанию битовый матричный шрифт 8х8 встроен в графический пакет и поэтому всегда доступен во время выполнения. Векторные шрифты все хранятся в отдельных файлах .CHR. Они могут загружаться во время выполнения или преобразовываться в файлы .OBJ

(при помощи утилиты BGIOBJ) и затем компоноваться с вашим файлом

.EXE.

Обычно подпрограмма settextstyle загружает файл шрифта,

распределяя память для него и затем загружая с диска соответствующий .CHR-файл. В качестве альтернативы данной схеме динамической

загрузки вы можете скомпоновать файл шрифта (или несколько таких

файлов) непосредственно с выполняемым файлом программы. Для этого

сначала требуется преобразовать файл .CHR в файл .OBJ (с помощью

утилиты BGIOBJ - прочтите об этом в файле документации UTIL.DOC,

который находится на дистрибутивном диске), а затем поместить в

исходную программу вызовы registerbgifont (перед вызовом

функции settextstyle) для того, чтобы зарегистрировать данный

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

Использование функции registerbgifont относится к сложным

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

Типы комбинированных блоков

Существуют 3 типа комбинированных блока: простой, раскрывающийся и раскрывающийся со списком. Все эти комбинированные блоки

выводят свою область редактирования, но блок списка в некоторых

из них может быть скрыт.

Простой комбинированный блок не может скрывать свою область

списка. Его область редактирования ведет себя как редактируемый

управляющий элемент. Пользователь может вводить и редактировать

текст, не обязательно совпадающий с одним из элементов списка.

Комбинированный блок с раскрывающимся списком ведет себя как

простой комбинированный блок, однако в начальном состоянии область списка не выводится. Она появляется после щелчка "мышью" на

пиктограмме справа от области редактирования.

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

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

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

которые содержатся в списке. Раскрывающиеся комбинированные блоки

могут воспринимать записи, отличные от элементов списка.

Типы ошибок

Ошибка Описание

SuspendBeforeRun	Пользователь вызвал Suspend перед вы зовом Start.
ResumeBeforeRun	Пользователь вызвал Resume перед вы зовом Start.
ResumeDuringRun	Пользователь вызвал Resume для нити, которая не была приостановлена.
SuspendAfterExit	Пользователь вызвал Suspend для объекта, нить которого уже завершилась.
ResumeAfterExit	Пользователь вызвал Resume для объекта, нить которого уже завершилась.
CreationFailure	Операционная система не смогла создать нить.
DestroyBeforeExit	Перед завершением нити вызван деструктор объекта.
AssignError	Попытка присвоить объект, не находящий ся в состоянии Create или Finish.

Типы сообщений

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

Типы UINT и WORD

Тип UINT создан и широко используется в API для создания типа данных, переносимого с Windows 3.x. UINT определяется как

typedef undigned int UINT;

UINT необходим из-за различий в размерах int между 16-разрядной Windows и Win32. Для 16-разрядной Windows int - это 16-битовое беззнаковое целое, а для Win32 - 32-битовое беззнаковое целое. Для описания целочисленных объектов, которые при компиляции

32-разрядных приложений предполагается расширить с 16 до 32 бит

используйте UINT.

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

typedef unsigned short WORD;

WORD описывает 16-битовое значение и в Windows, и в Word32.

Используйте этот тип для создания объектов, которые остаются

16-битовыми на обеих платформах. Поскольку описатели Win32 расширены до 32 бит, они больше не могут иметь тип WORD.

Типы указателей

Модель памяти Указатели функции Указатели данных

Tiny	near, _cs	near, _ds
Small	near, _cs	near, _ds
Medium	far	near, _ds
Compact	near, _cs	far
Large	far	far
Huge	far	far

Типы выражений

Вы можете использовать выражения для доступа к значением

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

функций. Формат записи шестнадцатиричного значения зависит от

выбранного механизма вычисления:

Язык 16-разрядный 32-разрядный

C	0xnnnn	0xnnnnnnnn
Pascal	$nnnn	$nnnnnnnn
Assembler	0nnnn	0nnnnnnnn

При отладке 16-битового кода для задания адреса памяти вы

можете использовать обозначение "сегмент:смещение", например:

Язык Формат Пример

C	Oxnnnn	Ox1234:Ox0010
Pascal	$nnnn	$1234:0010
Assembler	nnnnh	1234h:0B234h

Чтобы задать номер строки программы, перед десятичным номером строки укажите символ #. Можно задавать также байтовые списки:

Язык Список Данные

C	1234"AB"	34 12 41 42
Pascal	"ab"0x04"c"	61 62 04 63
Assembler	'ab'$04'c'	61 62 04 63

Функции из выражений вызываются также, как в исходном коде.

Это позволяет быстро проверить поведение функции.

Точки останова

В Turbo Debugger понятие точки останова включает в себя три

следующих элемента:

место в программе (адрес), где находится точка останова;

условие, при котором она срабатывает;

что происходит, когда срабатывает точка останова (действие).

Адрес может представлять собой отдельный адрес в программе

или быть глобальным (при этом останов может происходить на любой

строке исходного кода или инструкции программы). Под условиями

могут подразумеваться следующие условия, когда происходит останов:

всегда;

когда выражение принимает истинное значение;

когда объекты данных изменяют свое значение.

Можно также задавать "счетчик проходов", который определяет,

чтобы прежде чем сработает точка останова, "условие" должно принимать истинное значение определенное число раз.

При достижении точки останова может выполняться следующее

действие:

приостановка выполнения программы;

регистрация значения выражения;

выполнение выражения;

разрешение группы точек останова;

запрещение группы точек останова.

Обычно точка останова устанавливается на конкретной исходной

строке или машинной инструкции программы. Когда программа достигает точки останова, Turbo Debugger вычисляет ее. Однако точки

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

Когда программа доходит до точки останова, Turbo Debugger

проверяет условия точки останова и проверяет истинность заданного

условия. Если условие выполняется, точка останова срабатывает.

Такая точка останова называется условной.

Точку останова в шаблонах С++

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

Если точка останова устанавливается нажатием F2 в окне Module, то точки останова задаются для всех экземпляров классов в шаблонах. Это позволяет вам отладить поведение

шаблона.

Если для установки точки останова в шаблоне используются

клавиши Alt+F2, то активизируется диалоговое окно Breakpoint Options, и в поле ввода Address вы можете задать адрес

шаблона. Открываемое диалоговое окно позволяет вам выбрать

конкретный экземпляр класса.

Установить точку останова на конкретном экземпляре класса

шаблона можно также с помощью окна CPU. Позиционируйте

курсор на строке кода шаблона и нажмите F2.

Удаляются такие точки останова аналогично другим: позиционируйте курсор на точке останова в окне Module и нажмите F2. Удаляются все точки останова соответствующих экземпляров классов. Конкретные точки останова можно удалить с помощью окна CPU.

Трансляторы

Транслятор - это любая программа, которая преобразует один

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

Однако трансляторы, средства просмотра, другие инструментальные

средства и Style Sheet можно передать другому проекту - следующий

выбираемый с помощью команды Project New project проект их наследует. С помощью Options Tools вы можете просмотреть заданные по

умолчанию трансляторы.

Трассировка исключительных ситуаций операционной системы

В TD32 команда OS Exceptoions (в SpeedMenu области кода окна

CPU) открывает диалоговое окно Specify Exception Handling, в котором вы можете задать, как Turbo Debugger должен обрабатывать

исключительные ситуации операционной системы, генерируемые программой.

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

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

Turbo Debugger. Он приостанавливает программу и активизирует окно

Module или CPU, устанавливая курсор на соответствующую строку кода.

Чтобы изменить это заданное по умолчанию поведение, откройте

окно Specify Exception Handling, подсветите исключительную ситуацию, которую вы хотите обрабатывать вы программе, и щелкните

"мышью" на кнопке с независимой фиксацией User Program.

Если вы хотите, чтобы программа обрабатывала все исключительные ситуации операционной системы, используйте кнопку User

All.

Требования

При создании оверлеев следует помнить несколько простых правил, а именно:

Минимальная часть программы, которая может выделяться в

качестве оверлея, это сегмент.

Прикладные программы с оверлейной структурой должны иметь

одну из трех следующих моделей памяти: medium , large или

huge; модели tiny, small и compact оверлеи не поддерживают.

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

Генерация оверлеев во время компоновки полностью не зависит

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

оверлеями. Действительно, с точки зрения компоновщика программа

управления оверлеями является просто одним из подлежащих компоновке участков кода. Единственное предположение, которое делает

компоновщик, состоит в том, что программа управления оверлеями

воспринимает вектор прерываний (обычно INT 3FH), через который

происходит управление динамической загрузкой. Такой уровень

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

Требования к программному и аппаратному обеспечению

Для сеанса удаленной отладки вы можете выбрать соединение

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

Рабочая система с памятью, достаточной для загрузки отладчика (локальная система).

Другой компьютер РС (удаленная система), имеющий достаточный для отлаживаемых программ DOS и TDREMOTE объем памяти

(или для отлаживаемой программы Windows и WREMOTE). Это

удаленная система.

Две системы должны соединяться через последовательный порт

нуль-модемным кабелем. При соединении через локальную сеть потребуется программное обеспечение, совместимое с Novell Netware.

программное обеспечение, совместимое с Novell Netware (версии IPX

и NETBIOS 3.0 или старше).

- U -

Unable to create output file имя_файла

Фатальная ошибка этапа компиляции

(невозможно создать выходной файл)

Рабочий диск переполнен или защищен от записи, или выходной

каталог не существует. Если диск переполнен, попробуйте удалить

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

повторите компиляцию.

Unable to create torboc.$ln

Сообщение об ошибке этапа компиляции

(невозможно создать файл torboc.$ln)

Компилятор не может создать временный файл TURBOC.$LN, так

как не может получить доступ к диску, или диск переполнен.

Unable to execute command: команда

Фатальная ошибка утилиты MAKE

(нет возможности выполнить команду)

Это сообщение выдается после того, как команда должна была

выполнена. Это могло произойти из-за того, что командный файл не

был найден, или из-за того, что в нем были сделаны ошибки. Наименее вероятно, что команда существует, но каким-либо образом испорчена.

Unable to execute command команда

Сообщение об ошибке этапа компиляции

(нет возможности выполнить команду команда)

Невозможно найти TLINK или TASM, возможно диск запорчен.

Unable to open file имя_файла

Сообщение об ошибке утилиты TLINK или ошибка утилиты TLIB

(нет возможности открыть файл имя_файла)

Это происходит, если указанный файл не существует или задан

неверно.

Unable to open имя_файла

Сообщение об ошибке утилиты TLINK или ошибка утилиты TLIB

(нет возможности открыть файл имя_файла)

Это происходит, если указанный файл не существует или задан

неверно.

unable to open имя_файла for output

Сообщение об ошибке утилиты TLIB

(невозможно открыть файл имя_файла для вывода)

Утилита TLIB не может открыть указанный файл для вывода.

Обычно это вызывается недостатком места в целевой библиотеке, на

диске, или в файле листинга. Кроме того, данная ошибка происходит, если целевой файл существует, но он помечен как доступный

только по чтению.

Unable to open include file имя_файла

Сообщение об ошибке этапа компиляции

( нет возможности открыть включаемый файл имя_файла)

Названный файл компилятором не найден. Это могло произойти

из-за того, что включаемый файл (по директива #include) включает

самого себя, или вы не установили в CONFIG.SYS переменную FILES

(попробуйте FILES=20). Проверьте, существует ли найденный файл.

Unable to open include file имя_файла


Сообщение об ошибке утилиты MAKE

(нет возможности открыть включаемый файл имя_файла)

Названный файл не найден. Это могло произойти из-за того,

что включаемый файл включает самого себя или вы не установили в

CONFIG.SYS FILES (попробуйте FILES=20). Проверьте, существует ли

найденный файл.

Unable to open input file имя_файла


Сообщение об ошибке этапа компиляции

(невозможно открыть входной файл имя_файла)

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

Unable to open makefile


Сообщение об ошибке утилиты MAKE

(невозможно открыть формирующий файл)

Текущий каталог не содержит файла с именем MAKEFILE или MAKEFILE.MAK, а также файл, заданный с помощью -f.

Unable to redirect input or output


Сообщение об ошибке утилиты MAKE

(невозможно перенаправить ввод или вывод)

Утилита MAKE не может открыть временные файлы, необходимые

для изменения направления ввода или вывода. Если вы работаете в

сети, убедитесь, что вы имеете полномочия в текущем каталоге.

Unable to rename имя_файла in имя_файла


Сообщение об ошибке утилиты TLIB

(невозможно переименовать файл имя_файла в имя_файла)

Утилита TLIB строит библиотеку во временном файле, а затем

переименовывает временный файл в целевой библиотечный файл. Если

данная ошибка вызывается недостатком места на диске, то это будет

отмечено.

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


Сообщение об ошибке этапа компиляции

(неопределенная метка)

Указанная метка присутствует в операторе goto в функции, но

определения метки нет.

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

Предупреждение этапа компиляции

(неопределенная структура)



Указанная структура используется в исходно файле (возможно,

в указателе на структуру), но не имеет определения в исходном

файле. Обычно это вызывается опечаткой в имени структуры или пропущенным описанием.

Undefined structure структура


Сообщение об ошибке этапа компиляции

(неопределенная структура)

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

указателе на структуру), но нет определения структуры. Обычно это

вызывается опечаткой в имени структуры или пропущенным описанием.

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


Сообщение об ошибке этапа компиляции:

(неопределенный идентификатор)

Указанный идентификатор не имеет описания. Это может вызываться опечаткой в данном месте или в точке описания. Причиной

может быть также ошибка в идентификаторе.

Unexpected }


Сообщение об ошибке этапа компиляции

(непредвиденная скобка })

Там, где она не требуется, обнаружена лишняя фигурная скобка. Проверьте пропущенную скобку {.

Unexpected char X in command line


Сообщение об ошибке утилиты TLIB

(непредвиденный символ X в командной строке)

Утилита TLIB обнаружила при анализе командной строки синтаксическую ошибку.

Unexpected end of file


Сообщение об ошибке утилиты MAKE

(неправильное окончание файла)

Достигнут конец формирующего файла, а временный встроенный

файл не закрыт.

Unexpected end of file in comment started on номер_строки


Сообщение об ошибке этапа компиляции

(неправильное окончание файла в комментарии на строке номер_строки)

Исходный файл заканчивается в комментарии. Обычно это вызывается отсутствием завершения комментария (*/).

Unexpected end of file in conditional started on line номер_строки


Сообщение об ошибке утилиты MAKE или ошибка этапа компиляции

(Неправильное окончание файла в условном операторе на строке

номер_строки)

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

была или пропущена, или в ней имелась синтаксическая ошибка.



union cannot be a base type


Сообщение об ошибке этапа компиляции

( объединение не может быть базовым типом)

Объединение не может использоваться в качестве базового типа

для класса другого типа.

union cannot have a base type


Сообщение об ошибке этапа компиляции

(объединение не может иметь базовый тип)

Объединение не может быть производным из других классов.

Union member элемент is of type class with constructor


Сообщение об ошибке этапа компиляции

(элемент объединения имеет тип класса с конструктором). См. ниже.

Union member элемент is of type class with destructor


Сообщение об ошибке этапа компиляции

(элемент объединения имеет тип класса с деструктором). См. ниже.

Union member элемент is of type class with operator=


Сообщение об ошибке этапа компиляции

(элемент объединения имеет тип класса с operator=)

Объединение не может содержать элементы типа класса с определенными пользователем конструкторами, деструкторами или operator=.

Unions cannot have virtual member functions


Сообщение об ошибке этапа компиляции

(объединения не могут содержать виртуальные функции-элементы)

Unknown assembler instruction



Предупреждение этапа компиляции

(неизвестная инструкция Ассемблера).

Компилятор обнаружил оператор встроенного Ассемблера с недопустимым кодом. Проверьте правильность кода операции. Данное предупреждение по умолчанию выключено.

Unknown command line switch X ignored


Сообщение об ошибке утилиты TLIB

(недопустимый параметр командной строки игнорируется)

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

Unknown language, must be C or C++


Сообщение об ошибке этапа компиляции

(недопустимый язык, должен быть Си или С++)

В конструкции C++:

extern "name" type func { /* ... */ };

Именем, указанным в кавычках, должно быть "C" или "C++".

Имена других языков не распознаются. Например, вы можете описать

внешнюю функцию Паскаля без переименования компилятора, например:



extern "C" int pascal func { /* ... */ };

Функция С++ (возможно переопределяемая) должна описываться

как Pascal, что допускает обычное переименование компилятора (и

переопределение):

extern int pascal func { /* ... */ };

Unknown option -> параметр


Сообщение об ошибке утилиты TLINK

(неизвестный параметр)

В командной строке или в файле подсказки обнаружен символ /

или -, либо символ параметра DOS, за которым не следует ни один

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

регистре.

Unknown preprocessor directive: идентификатор


Сообщение об ошибке этапа компиляции

(неизвестная директива препроцессора)

Компилятор обнаружил в начале строки символ #, но последующее имя не является допустимым именем директивы, либо неправильно

сформирована остальная часть директивы.

Unknown preprocessor statement


Сообщение об ошибке утилиты MAKE

(неизвестный оператор препроцессора)

В начале строки обнаружен символ !, но следующим далее именем не является имя error, undef, if, elif, include, else или

endif.

Unreachable code


Предупреждение этапа компиляции

(недостижимый код)

За break, continue, goto или return не следует метка или конец цикла либо функции. Компилятор проверяет циклы while, do и

for на анализ константы (условия) и пытается распознать циклы,

которые не проходятся целиком.

Unsupported option строка


Сообщение об ошибке утилиты TLINK

(неподдерживаемый параметр)

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

Undeterminated string or character constant


Сообщение об ошибке этапа компиляции

(незавершенная строка или символьная константа)

Компилятор не обнаружил закрывающую кавычку после начала

строки или символьной константы.

Use of . or -> to call функции


Сообщение об ошибке этапа компиляции:

(использование для вызова функции . или ->)

Вы пытаетесь вызвать функцию-элемент, не задавая объект.

Use of . or -> to call элемент, or & to take its address


Сообщение об ошибке этапа компиляции:

(использование для вызова элемента . или -> или операции &



для получения его адреса)

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

адрес должен получаться с помощью операции &.

Use :: to take the address of a member function


Сообщение об ошибке этапа компиляции

(для получения адреса функции-элемента используйте ::)

Если f - это функция-элемент класса с, вы можете получить ее

адрес с помощью синтаксиса &c::f. Обратите внимание на использование имени типа класса, а не имени объекта, и на операцию ::,

отделяющую имя класса от имени функции. (Указатели функций-элементов не являются подлинными типами указателей, и они не ссылаются на конкретный элемент класса.)

use /e with TLINK to obtain debug information from library


Сообщение об ошибке утилиты TLIB

(используйте параметр компоновщика /e для получения отладочной информации из библиотеки)

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

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

поддерживает расширенный словарь, следовательно в интегрированной

среде параметры менять не нужно.

Use of : and :: dependent for target цель


Сообщение об ошибке утилиты MAKE

(использование зависимости :: и : для целевого файла)

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

filea: fileb

filea:: filec

Use qualified name to access nested type тип


Предупреждение этапа компиляции

(использование уточненного имени для доступа к вложенному

типу)

В старых версиях Си и С++ определения typedef и имена признаков. описанные внутри классов, были непосредственно доступны в

глобальной области действия. В последних спецификациях С++ этим

именам, если они должны использоваться вне области действия их

класса, должен предшествовать квалификатор class::квалификатор.

Чтобы можно было компилировать старый код, когда такое имя определяется в отдельном классе, Borland C++ допускает использование

без class:: и выводит данное предупреждение.

User break


Сообщение этапа компиляции

(прерывание пользователя)

При компиляции или компоновке в интегрированной среде вы нажали клавиши Ctrl+Break, прервав процесс. (Это не ошибка, а просто подтверждение.)

Удаление класса

Удалите исходный класс файла из проекта IDE (выбрав исходный узел, щелкнув правой кнопкой "мыши" и выбрав Delete

node). Если исходный файл используется в других классах,

удалите ссылки на класс в других исходных файлах.

Выберите в проекте AppsExpert, щелкните на нем правой

кнопкой "мыши" и выберите Special Rescan. Rescan сканирует

исходные файлы, перечисленные как зависимые файлы, и использует для построения целевого файла AppsExpert. После завершения Rescan вы возвращаетесь в обновленный исходный

файл проекта и можете построить свое приложение с помощью

ClassExpert.

Удаление точек останова

Удалить точки останова можно с помощью локального меню (SpeedMenu) окна Breakpoints или меню Breakpoints. Команда Remove меню окна Breakpoints или клавиша Del стирают точку останова, подсвеченную в области списка. Команда Delete All меню Breakpoint и

локального меню окна Breakpoints удаляют все установленные точки

останова.

Удаление записей-комментариев: параметр /O

Параметр /O указывает библиотекарю, что из библиотеки нужно

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

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

Удаленная отладка

Удаленная отладка означает с соответствии со своим названием

следующее: вы запускаете отладчик на одном компьютере, а отлаживаемую программу - на другом. Две системы могут соединяться через

последовательный порт или через локальную сеть LAN, совместимую с

NETBIOS. Удаленную отладку полезно использовать в следующих ситуациях:

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

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

ошибках распределения памяти.

Нужно отладить специальные программы (резидентные программы или драйверы устройств).

Вы отлаживаете программу Windows.

В случае отладки прикладной программы Window у вас есть выбор: вы можете либо запустить на одной машине программу и отладчик для Windows (TDW), либо запустить Windows, утилиту WREMOTE и

прикладную программу на одной машине, а отладчик - на другой.

Указатели

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

умолчанию тип указателя, используемый для кода и данных. Существует 4 типа указателей: near (16 бит), far (32 бита), huge (32

бита) и segment (16 бит).

В указателях near (ближние указатели) для вычисления адреса

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

регистра кода CS. С такими указателями легко работать.

Указатели far (дальние указатели) содержат не только смещение в сегменте, но и адрес сегмента (другое 16-битовое значение).

Такие указатели позволяют иметь несколько сегментов кода и программы, превышающие по размеру 64К. Здесь нужно учитывать, что в

операциях == и != используются 32-битовые значения unsigned long,

а не полный адрес памяти. В операциях сравнения <=, >=, < и > используется только смещение.

При прибавлении к указателю значения изменяется только смещение. Если смещение превышает FFFF (максимально возможное значение), то указатель возвращается к началу сегмента. При сравнении

указателей лучше использовать ближние указатели или указатели huge.

Указатели huge также занимают 32 бита. Аналогично указателям

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

возможным значением в сегментном адресе. Так как сегмент может

начинаться с каждых 16 байт, это означает, что данное смещение

будет иметь значение от 0 до 15. Для нормализации указателя он

конвертируется в 20-битовый адрес, а затем используются правые 4

бита смещения и левые 16 бит адреса сегмента. Например, 2F84:0532

преобразуется в абсолютный адрес 2FD72, который нормализуется в

2FD7:0002. Нормализация важна по следующими причинам:

Каждому сегментному адресу соответствует при этом только

одна возможная адресная пара "сегмент:смещение". Это означает, что операции == и != возвращают корректный ответ.

В операциях сравнения <=, >=, < и > используется при этом

полные 32-битовые значения. Нормализация обеспечивает корректность результатов.

Благодаря нормализации смещение в указателях huge автоматически циклически возвращаются каждые 16 байт, но настраивается также и сегмент. Например, при инкрементации 811B:000F результатом будет 811C:0000. Это обеспечивает,

что, например, при наличии массива структур типа huge >

64К индексирование массива и выбор поля struct будет работать для структур любого размера.

Однако работа с указателями huge связана с дополнительными

издержками. Из-за этого арифметические операции с указателями huge выполняются намного медленнее, чем с указателями far.

Указатели сегментов

В объявлениях типа указателя сегмента используется __seg. В

результате получаются 16-битовые указатели сегментов. Синтаксис

__seg следующий:

тип_данных _seg *идентификатор

Например,

int _seg *name

Любое обращение по ссылке через "идентификатор" предполагает

смещение 0. В арифметических операциях с указателями выполняются

следующие правила:

Нельзя использовать с указателями сегментов операции ++,

--, +- или -=.

Нельзя вычитать один указатель сегмента из другого.

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

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

указывает на тип void. Независимо от указываемого типа

умножение смещения не происходит.

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

указатель.

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

объекта, на который указывает целочисленный операнд.

Арифметическая операция выполняется таким образом, как

если бы целое складывалось с указателем far или вычиталось из него.

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

для unsigned int). Другими словами, за исключением перечисленных выше ограничений, они обрабатываются так же, как и любые другие указатели.

Улучшение алгоритма

Хотя наш алгоритм работает чудесно, но он довольно ограничен в

своих возможностях, так как может декомпрессировать только непосредственно на экран. Поскольку цикл while находится в функции, то

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

и пропускаете текст для декомпрессии один символ за цикл времени к

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

сжатый текст -> Декомп > Анализ. > лексемы

фильтр симв.

Это сделает наш декомпрессор весьма гибким и переносимым. Как мы

можем изменить наш алгоритм, написанный на Си?

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

также содержать указатель на строку, которую необходимо декомпрессировать, и длину этой строки:

typedef struct {

> int srclen, c, rcnt; <

> unsigned char *p;

} decompressor;

void decomp(unsigned char *s, int srclen)

{ ----------

int | c, rcnt; |

----------

...

}

Примечание:

Теперь попробуем расщепить нашу функцию decomp() на две части:

функцию инициализации и функцию возвращающую следующий символ, с автоматическим включением его в процесс декомпрессии. Далее передадим

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

Сначала опишем функцию инициализации:

void decompressor_init(decompressor* dc, unsigned char* s, int len)

{

dc->p = s; /* Место сжатия строки */

dc->srclen = len; /* Инициализация переменной содержащей длину */

dc->rcnt = 0; /* Обнуление счетчика длины строки */

}

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

Операция Смысл

&	Операция адресации
*	Операция обращения по ссылке
+	Унарный плюс
-	Унарный минус
~	Поразрядное дополнение (дополнение до единицы)
!	Логическое отрицание
++	Префикс: прединкрементация; Постфикс: постинкрементация
--	Префикс: преддекрементация; Постфикс: постдекрементация

Уничтожение интерфейсных объектов

Уничтожение интерфейсного объекта предусматривает два этапа:

уничтожение интерфейсного элемента и удаление интерфейсного объекта. Если создавать и выводить интерфейсный элемент требуется

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

Уничтожение интерфейсного элемента выполняет функция-элемент

Destroy интерфейсного объекта. Для уничтожения интерфейсных элементов Destroy вызывает функцию API DestroyWindow. При уничтожении интерфейсного элемента элемент данных HWindow устанавливается в 0.

При закрытии пользователем окна происходит следующее:

Windows уведомляет окно.

Возможность закрытия окна проверяется через механизм CanClose.

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

Интерфейсный объект - это обычный объект С++, и вы можете

удалить его с помощью оператора delete.

Уничтожение окон

Уничтожение родительского окна означает уничтожение всех его

дочерних окон. Уничтожать дочерние окна или интерфейсные объекты

дочерних окон явным образом не требуется. Это же касается механизма CanClose: CanClose для родительского окна может вызывать CanClose для всех дочерних окон.

Когда вы уничтожаете интерфейсный элемент объекта, он разрешает автоматическое создание всех дочерних объектов независимо от

того, было ли оно до этого разрешено. Таким образом, при создании

родительского объекта все родительские объекты восстанавливаются

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

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

не хотите автоматически создавать.

Управление цветом

Ниже приводится краткое описание функций для управления цветом изображений:

Функции получения информации о цвете Описание

getbcolor	Возвращает текущий цвет фона.
getcolor	Возвращает текущий цвет вычерчивания.
getdefaultpalette	Возвращает структуру определения палитры.
getmaxcolor	Возвращает максимальное значение цвета доступное в текущем графическом режиме.
getpalette	Возвращает текущую палитру и ее размер.
getpalettesize	Возвращает размер просмотровой таблицы палитры.

Функции установки одного или более цветов Описание

setallpalette	Изменяет все цвета палитры, как задано.
setbkcolor	Устанавливает текущий цвет фона
setcolor	Устанавливает текущий цвет вычерчивания.
setpalette	Изменяет один из цветов палитры, как указано ее аргументами.

Прежде чем перейти к рассмотрению работы функций управления

цветом изображения, дадим базовое описание того, как эти цвета

фактически получаются на вашем графическом экране.

Управление цветом для EGA и VGA

В случае EGA палитра содержит 16 элементов из общего количества 64 возможных цветов, причем каждый из элементов палитры

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

палитры ("аппаратные номера цветов", хранимые в палитре). Элементы палитры можно изменять как по отдельности при помощи

setpalette, либо все сразу через функцию setallpalette.

Палитра EGA по умолчанию соответствует 16 цветам CGA, которые были даны в предыдущей таблице цветов: черный равен элементу

0, голубой равен элементу 1, ... , белый равен элементу 15. В

graphics.h определены константы, которые содержат соответствующие

цветам аппаратные значения: это EGA_BLACK, EGA_WHITE и т.д. Эти

значения могут быть также получены через функцию getpalette.

Подпрограмма setbkcolor(цвет) на EGA работает несколько иначе, чем на CGA. На EGA setbkcolor копирует фактическое значение

цвета, хранящееся в элементе #цвет, в элемент #0.

Что касается цветов, то драйвер VGA работает фактически так

же, как и драйвер EGA; он просто имеет более высокое разрешение

(и меньшие по размеру элементы изображения)

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

Из-за различий в графическом аппаратном обеспечении фактическое управление цветами различно для CGA и EGA, что заставляет

нас рассмотреть их по отдельности. Управление цветом для драйвера

AT&T, а также режимы низкой разрешающей способности драйвера MCGA

аналогичны управлению цветом CGA.

В случае адаптера CGA вы можете выбрать либо режим низкой

разрешающей способности (320х200), который допускает использование четырех цветов, либо режим высокой разрешающей способностей

(640х200), где допускается использование двух цветов.

Управление диапазоном полосы прокрутки

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

полосы прокрутки. По умолчанию диапазон объекта составляет от 1

до 100. Минимальная позиция скользящего маркера (верхний конец

вертикальной полосы или левый конец горизонтальной) устанавливается в 1. Другой диапазон можно задать с SetRange.

Полоса прокрутки имеет два важных атрибута - размер строки

(инициализируется значением 1) и размер страницы (по умолчанию

10). Эти значения задаются в единицах диапазона. Их можно изменить с помощью элементов данных TScrollBar LineMagnitude и PageMagnitude.

TScrollBar имеет две функции-элемента для опроса полосы

прокрутки: GetRAnge (получает диапазон) и GetPosition (получает

текущую позицию указателя). Модификация полос прокрутки обычно

выполняется пользователем, но ваше приложение может изменить их

непосредственно с помощью функций-элементов SetRange (устанавливает диапазон прокрутки), SetPosition (устанавливает позицию маркера) и DeltaPos (перемещает маркер).

Управление Doc/View

Администратор документа поддерживает список используемых в

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

Администратор документа объединяет модель Doc/View - классы

документа, классы отображаемых элементов и шаблоны. Администратор

документа предусматривает заданное по умолчанию меню File и обработку каждого его пункта:

Пункт меню Обработка

New	Создает новый документ.
Open...	Открывает существующий документ.
Save	Сохраняет текущий документ.
As...	Сохраняет текущий документ под новым именем.
Revert To Saved	Отменяет изменения в последнем сохраненном документе.
Close	Закрывает текущий документ.
Exit	Выходит из приложения, выводя подсказку для сохранения документов.

После написания документа и классов отображаемых элементов,

определения всех необходимых шаблонов и создания экземпляров текущих шаблонов вам потребуется только создать свой администратор

документа. После создания администратора он создает список экземпляров шаблона и меню (если это задано в конструкторе). После

получения одного из обрабатываемых событий он выполняет заданную

для этого события команду.

Управление графической системой

Ниже приводится краткое перечисление всех функций управления

графической системой:

Функция Описание

closegraph	Закрывает графическую систему.
detectgraph	Проверяет аппаратное обеспечение и определяет, какие графические драйверы использовать; рекомендует предпочтительный режим.
graphdefaults	Сбрасывает все переменные графической системы в значения по умолчанию.
_graphfreemem	Отменяет выделенную графике память. Используется для определения собственной подпрограммы.
_graphgetmem	Распределяет память графике; используется для определения собственной подпрограммы.
getgraphmode	Возвращает текущий графический режим.
getmoderange	Возвращает минимальный и максимальный допустимые режимы для заданного драйвера.
initgraph	Инициализирует графическую систему и переводит аппаратное обеспечение в графический режим.
installuserdriver	Устанавливает дополнительный драйвер устройства в таблице драйверов устройства BGI.
installuserfont	Загружает поставляемый файл векторного (штрихового) шрифта в таблицу символьных файлов BGI.
registerbgldriver	Регистрирует внешний или загруженный пользователем файл драйвера для включения во время компоновки.
restorecrtmode	Восстанавливает первоначальный (существовавший до Initgraph) режим экрана.
setgraphbufsize	Задает размер внутреннего графического буфера.
setgraphmode	Выбирает заданный графический режим, очищает экран и восстанавливает все умолчания.

Графический пакет компилятора Borland C++ обеспечивает графические драйверы для следующих графических адаптеров (и полностью совместимых с ними):

Цветной/графический адаптер (CGA);

Многоцветная графическая матрица (MCGA);

Улучшенный графический адаптер (EGA);

Видеографическая матрица (VGA);

Графический адаптер Hercules;

Графический адаптер серии AT&T 400;

Графический адаптер 3270 PC;

Графический адаптер IBM 8514.

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

драйвер и переводит систему в графический режим.

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

initgraph автообнаружение, то она сама вызовет функцию detectgraph для выбора графического драйвера и режима. Если вы задали в

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

таком случае непредсказуем.

После того, как графический драйвер загружен, вы можете определить его имя при помощи функции getdrivename, а число поддерживаемых драйвером режимов - при помощи функции getmaxmode. Функция getgraphmode сообщит вам, в каком графическом режиме вы находитесь в текущий момент. Имея номер режима, вы можете определить

его имя при помощи функции getmodename. Вы также имеете возможность изменить графический режим при помощи функции setgraphmode

и вернуть исходный видеорежим (тот, который был установлен до

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

графическую систему (загруженные шрифты и драйверы останутся в

памяти).

Функция graphdefaults сбрасывает установки состояния графической системы (размеры графического окна, цвет линий, цвет и

шаблон заполнителя и т.д.) в исходное состояние. Функции installuserdriver и installuserfont позволяют установить в графической

системе новые драйверы устройства и шрифты.

И наконец, закончив работу в графике, вы должны вызвать

функцию closegraph для того, чтобы закрыть графическую систему.

Функция closegraph выгружает драйвер из памяти и восстанавливает

первоначальный видеорежим (через обращение к restorecrtmode).

Обычно подпрограмма initgraph загружает графический драйвер,

распределяя для этого драйвера память и затем загружая туда с



диска соответствующий файл .BGI. В качестве альтернативы данной

схеме динамической загрузки вы можете скомпоновать нужный файл

графического драйвера (или несколько таких файлов) непосредственно с файлом выполняемой программы. Для этого файл .BGI сначала

преобразуется в файл .OBJ (при помощи утилиты BGIOBJ - см. документацию в файле UTIL.DOC, который поставляется на одном из дистрибутивных дисков), после чего в исходный код помещается вызов

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

После определения того, какой графический драйвер должен использоваться (посредством detectgraph) функция initgraph проверяет, был ли желаемый драйвер зарегистрирован. Если был, то initgraph обращается к зарегистрированному драйверу непосредственно в памяти. В противном случае функция initgraph распределяет память для драйвера и загружает нужный файл .BGI с диска.

Использование функции registerbgidriver относится к более

сложным методам программирования, не рекомендуемым для начинающих

программистов.

Во время выполнения графической системе может понадобиться

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

При необходимости она вызывает функцию _graphgetmem для распределения памяти и функцию _graphfreemem для ее освобождения. По

умолчанию данные подпрограммы просто вызывают функции malloc и

free, соответственно.

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

графики. Однако, ваши варианты функций управления распределением

памяти должны иметь те же имена: они заменят собой используемые

по умолчанию функции с теми же именами из стандартных библиотек

языка Си.

Определив собственные функции _graphgetmem и _graphfreemem,

вы можете получить предупреждение "duplicate symbols" ("повторение символических имен"). Это предупреждение можно игнорировать.

Управление памятью

Контейнеры позволяют вам контролировать управление памятью.

Например, следующий контейнер позволяет передавать объект управления памятью:

TMQueueVector<MyClass, MyMemManage> MyQueue (100);

TMQueueVector воспринимает два типа параметров: объект, который будет содержать очередь (MyClass), и имя класса управления

памятью (MyMemManage), который вы хотите использовать. M в имени

шаблона означает, что вы должны для реализации данного контейнера

задать администратор памяти. Если в именах шаблонов M не указывается, то используется стандартный распределитель памяти

TStandardAllocator, найденный в alloctr.h.

TStandardAllocator предусматривает операции new, new[],

delete и delete[], которые вызывают соответствующие глобальные

функции. Пользовательское распределение памяти должно предусматривать специфическую для класса операцию new. В качестве примера

для построения можно использовать содержимое alloctr.h.

Управление выполнением программы

В процессе отладки управление периодически передается между

вашей программой и отладчиком. Когда управление передается Turbo

Debugger, он может использовать свои средства для поиска по ис ходному коду и структурам данных программы и выявления причины

неправильного выполнения программы. Для этого можно использовать

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

управления выполнением программы. Вы можете:

выполнять программу по шагам (по одной машинной инструкции

или строке исходного кода);

выполнять как один шаг вызовы функций;

выполнять программу до заданного места;

выполнять программу до возврата из текущей функции;

трассировать программу;

выполнять программу в обратном направлении;

выполнять программу до точки останова;

выполнять программу до появления определенного сообщения

Windows;

приостанавливать программу при возникновении исключитель ной ситуации С++ или Си.

Кроме точек останова, сообщений Windows и исключительных си туаций С++ все механизмы управления выполнением находятся в меню Run.

Управляющие объекты Visual Basic

ObjectWindows позволяет вам использовать в приложениях Windows управляющие элементы, совместимые с управляющими элементами

Visual Basic 1.0 (VBX). Использовать их также легко, как стандартные управляющие элементы Windows или ObjectWindows.

Управляющие элементы VBX представляют большой диапазон функциональных возможностей, не предусмотренных в стандартных управляющих элементах Windows.

---