Сообщения ввода
| 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
| |
| 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 используют 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 |
Типы выражений
Вы можете использовать выражения для доступа к значением
идентификаторов программы, вычисления значений и изменения значений элементов данных. Допускается задавать шестнадцатиричные значения, адреса памяти, строки программы, байтовые списки и вызовы
функций. Формат записи шестнадцатиричного значения зависит от
выбранного механизма вычисления:
| 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.
