Word — Тип Delphi


Word — Тип Delphi

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

Заметим, что TF_MAin – это мой идентификатор формы. У вас этот параметр будет отличаться. Его можно посмотреть в «interface»->«type» первой строкой TF_MAin = class(TForm).

Не забываем, что в файле необходимо расставить эти слова в формате <%VasheSlovo%>. Только на английском и именно в таких скобках. Чтобы он случайно не заменил другой текст. На самом деле вы можете заменять любые слова, только порой это будет чревато. А так уж точно не замените другой текст.

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

Word — Тип Delphi

Delphi – это один из самых популярных и эффективных инструментов разработки сложных приложений и возможность интегрировать средства приложений MS Office в разрабатываемые в этой среде проекты.

Известно, что Word и Excel является OLE – объектом. Суть OLE технологии возможность из разрабатываемого приложения (клиента) взаимодействовать с другими приложениями (серверами). Все приложения Microsoft Office являются так называемыми «серверами автоматизации». Microsoft Word , являясь сервером OLE , позволяет подключаться к себе клиентам и использовать свои методы и свойства.

Работа с MS Word в Borland Delphi. Для работы с Word файлами нам потребуется библиотека ComObj , которая входит в стандартную поставку Borland Delphi . Подключается она в разделе Uses .

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

Сначала вводим вариантную переменную, затем создаем объект OLE Word . Application , и присваиваем его этой переменной. Эта процедура называется «создание экземпляра сервера». Создав этот объект, мы затем программируем его свойства и методы.

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

Создание нового документа. Создание документа производится методом Add . Синтаксис метода :

Add (Template, NewTemplate, DocumentType, Visible);

Все параметры метода – типа Variant необязательны.

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

Если использовать значение True , то новый документ открывается как шаблон. Значение по умолчанию – False .

Может принимать одно из следующих значений констант типа WdNewDocumentType : wdNewBlankDocument ( новый чистый документ), wdNewEmailMessage ( электронное сообщение) или wdNewWebPage ( Web – страница). Значение по умолчанию wdNewBlankDocument .

Управляет видимостью созданного документа. Если указать значение True , то документ будет видим. По умолчанию Microsoft Word открывает документ с свойством Visible установленным в True .

Так как все параметры являются необязательными, то для создания нового документа по шаблону Normal метод можно применить без параметров:

Открытие документа . Открытие существующего документа Word реализуется методом Open . Синтаксис метода :

Open (FileName, ConfirmConversions, ReadOnly, AddToRecentFiles, PasswordDocument, PasswordTemplate, Revert, WritePasswordDocument, WritePasswordTemplate, Format, Encoding, Visible);

Кроме параметра FileName все остальные необязательны.

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

Если в значении этого параметра указать значение True , то в случае открытия документа с форматом, отличного от Word , будет выводится диалоговое окно конвертирования файла. Необязательный параметр.

Указывая True , открываем документ только для чтения. Необязательный параметр.

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

Пароль открываемого документа. Необязательный параметр.

Пароль открываемого шаблона. Необязательный параметр.

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

Пароль для сохраняемого документа. Необязательный параметр.

Пароль для сохраняемого шаблона. Необязательный параметр.

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

wdOpenFormatAuto , wdOpenFormatDocument, wdOpenFormatEncodedText, wdOpenFormatRTF,

По умолчанию wdOpenFormatAuto . Необязательный параметр.

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

Устанавливая True , предусматриваем видимое открытие документа. По умолчанию установлено True . Необязательный параметр.

Например, для открытия документа « c :\1. doc « метод Open применяется как

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

Обращение к документу . Обращение к открытому документу, как к элементу набора коллекции, можно по порядковому номеру методом Item . Например, обращение ко второму документу будет выглядеть как:

Нумерация всех элементов в коллекции начинается с единицы, а не с нуля. Аналогичную операцию можно осуществить еще как:

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

Application.Documents.Item(2).Activate; или по имени файла

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

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

выражение. Range (начало области, конец области);

Например, объявленный ниже объект Range 1 охватывает собой первые 10 символов второго документа.

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

Вставка текста производится двумя методами объекта Range : InsertAfter и InsertBefore . Синтаксис методов:

Этим методом производится вставка текста после начала объекта Range выражение. InsertBefore( текст), а этим – до.

При использовании этих методов, в качестве параметра указать нужно только текст в апострофах. К примеру, вызов двух операторов даст нам две строки: это вставленный текст InsertBefore и это текст InsertAfter :

Range 1. InsertBefore ( ‘это вставленный текст InsertBefore ‘);

У объекта Range есть много полезных свойств. Например:

Свойство Font (шрифт), которое имеет свои подсвойства:

Font.Bold:=True – жирность шрифта

Font.Name:=»Arial» – название шрифта

Font.Size:= 24 – размер шрифта

Font.Color:= clRed – цвет шрифта

Font.Italic:= True – наклонность шрифта

Например , вставка жирной строки зеленого цвета:

Range1.InsertAfter( ‘ вставленная строка ‘);

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

Работа с Excel файлами в Delphi. Для работы с Excel файлами в Delphi так же нужно подключить модуль ComObj в разделе Uses .

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

Excel := CreateOleObject (‘ Excel . Application ‘);

Сначала вводим вариантную переменную, затем создаем объект OLE Excel . Application , и присваиваем его этой переменной. Эта процедура называется «создание экземпляра сервера». Создав этот объект, мы затем программируем его свойства и методы.

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

Создание новой книги:

Открытие существующей книги (где путь – путь к файлу с расширением xls.):

Открытие существующей книги только для чтения:

Excel.Workbooks.Open[ путь , 0, True];

Excel . Application . Quit ;

Отображаем или скрываем Excel на экране:

Печать содержимого активного листа Excel:

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

// чтение значения из ячейки

s:=Excel.Range[‘A2’]; где A2 – адрес ячейки .

Или используя стиль ссылок R1C1:

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

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

Excel.Range[Excel.Cells[1, 1],Excel.Cells[5, 3]].Select; либо

При этом будет выделена область находящаяся между ячейкой A1 и C5.

После выполнения выделения можно установить:

1) Объединение ячеек :

2) Перенос по словам:

3) Горизонтальное выравнивание:

при присваивании значения 1 используется выравнивание по умолчанию,

при 2 – выравнивание слева,3 – по центру, 4 – справа.

4) Вертикальное выравнивание

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

5) Граница для ячеек:

При значении 1 границы ячеек рисуются тонкими сплошными линиями. Кроме этого можно указать значения для свойства Borders, например, равное 3. Тогда установится только верхняя граница для блока выделения:

Значение свойства Borders задает различную комбинацию граней ячеек.В обоих случаях можно использовать значения в диапазоне от 1 до 10.

Word — Тип Delphi

Школа программирования Delphi

Портал DelphiSchool является бесплатным проектом, обеспечивающим пользователям быстрый и легкий доступ к урокам программирования на Delphi. Сайт позволяет научиться программировать на Делфи любому, кто хочеть писать свои программы, игры, Android приложения, программы для MAC OC или IOS. Кроме уроков Delphi и статей Delphi, на сайте доступны также и видеоуроки. Практически к каждому уроку, пользователю доступен исходник, изучив который, он сможет наглядно посмотреть как работает та или иная программа, написанная на Делфи. Кроме того мы постараемся прилагать к каждому материалу (статье, уроку, видеоуроку) файлы Delphi, которые будут помогать изучить предоставленный материал.

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

Давайте рассмотрим аргументы метода Open, их типы и функциональное значение:
FileName: string — путь и имя файла;
ConfirmConversions: boolean — False — не открывать диалоговое окно «Преобразование файла» при открытии файла, формат которого не соответствует формату Word (doc или docx)
ReadOnly:boolean — True — открыть документ в режиме «Только для чтения»
AddToRecentFiles: boolean — True, чтобы добавить документ в список недавно открытых документов.
PasswordDocument: string — пароль для открытия документа
PasswordTemplate: string — пароль для открытия шаблона
Revert : boolean — True, чтобы вернуться к сохраненному документу, если этот документ открывается повторно.
WritePasswordDocument: string — пароль для сохранения измененного документа в файле
WritePasswordTemplate:string — пароль для сохранения изменений в шаблоне
Format:integer — формат открываемого документа.

Обязательным параметром метода Open является только FileName, остальные параметры могут отсутствовать, как отсутствуют в вышеприведенном примере кода. Но если вдруг нам понадобится воспользоваться некоторыми из этих параметров, то их необходимо явно указать при вызове метода. Например, если мы решим открыть файл в режиме «Только для чтения», то код будет выглядеть следующим образом:

Аргументы метода SaveAs, их типы и функциональное назначение представлены ниже:
FileName: String — Путь и имя файла
FileFormat — Число Формат файла
LockComments: Boolean — True — не сохранять комментарии
Password: String — Пароль, который будет использоваться при открытии документа
AddToRecentFiles: Boolean — True — добавить имя файла в список меню File
WritePassword: String — Пароль, который будет использоваться для сохранения документа
ReadOnlyRecommended: Boolean — True — в последующем документ можно открыть «только для чтения»
EmbedTrueTypeFonts: Boolean — True — при сохранении перевести шрифты документа в TrueType
SaveNativePictureFormat: Boolean — Используется для импорта графики из форматов, не поддерживаемых Windows. True — импортировать только графику, поддерживаемую Windows
SaveFormsData: Boolean — True — сохранить форму документа без текста
SaveAsAOCELetter: Boolean — Используется в версиях Word для компьютеров Apple Macintosh

При вызове метода SaveAs, как и при Open, можно задавать как один, так и несколько аргументов. Но, как правило, достаточно только первого аргумента (путь и имя файла).
Ну и последнее что мы рассмотрим – это закрытие документа. Закрыть документы можно с помощью метода Close коллекции Documents. Создадим обработчик события OnClick для кнопки «Закрыть документ Word» и напишем код:

К уроку (статье) Основы работы с MS Word. Создание, открытие, сохранение и закрытие документа Word с помощью Delphi прилагается исходник, посмотрев который, вы можете ознакомиться с полным исходным кодом программы и посмотреть как работает созданная программа. Исходный код сопровождается комментариями, благодаря чему вы сможете легко в нем разобраться. Но я настоятельно рекомендую делать все самостоятельно. Так вы лучше и быстрее усвоите то, о чем говорилось в этом уроке

Для того чтобы получить возможность скачать исходник Delphi к этому уроку, необходимо посетить сайт рекламодателя. После этого, появится ссылка на исходник Delphi к уроку Основы работы с MS Word. Создание, открытие, сохранение и закрытие документа Word с помощью Delphi
Нажмите на эту ссылку Ссылка

Импорт информации из Delphi в Word

Известно, что Word является OLE-объектом. Суть OLE технологии — возможность из разрабатываемого приложения(клиента) взаимодействовать с другими приложениями(серверами). Все приложения Microsoft Office являются так называемыми «серверами автоматизации». Microsoft Word , являясь сервером OLE, позволяет подключаться к себе клиентам и использовать свои методы и свойства.

Алгоритм импорта данных в Word следующий:
1) создаем подключение к серверу-приложению Word,
2) создаем или открываем существующий документ
3) вносим в документ изменения
4) манипулируем документом, как хотим (сохраняем его, не показывая при этом экране или же наоборот),
5) отсоединяемся от сервера.

1) Подключение к серверу Word производится следующим образом:

var
Application: variant;
begin
Application:= CreateOleObject(‘Word.Application’);
end;

Сначала вводим вариантную переменную, затем создаем объект OLE ‘Word.Application’ , и присваиваем его этой переменной. Эта процедура называется «создание экземпляра сервера». Создав этот объект, мы затем программируем его свойства и методы.

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

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

Создание документа производится методом Add :

Синтаксис метода: Add ( Template, NewTemplate, DocumentType, Visible)

Все параметры метода — типа Variant и необязательны,

Имя шаблона, по которому создается новый документ. Если значение не указано, то используется шаблон Normal.
Если использовать значение True , то новый документ открывается как шаблон. Значение по умолчанию — False .
Может принимать одно из следующих значений констант типа WdNewDocumentType : wdNewBlankDocument ( новый чистый документ ) , wdNewEmailMessage( электронное сообщение ) или wdNewWebPage( Web-страница ) . Значение по умолчанию wdNewBlankDocument .
Управляет видимостью созданного документа. Если указать значение True , то документ будет видим. По умолчанию Microsoft Word открывает документ с свойством Visible установленным в True .

Так как все параметры являются необязательными, то для создания нового документа по шаблону Normal метод можно применить без параметров:

Для создания нового документа по шаблону метод применяется следующим образом

Application.Documents.Add(‘C:\Program Files\
Microsoft OfficeD9\Шаблон.dot’);

Например, создание нового документа в виде Web-страницы будет выглядеть как

Var
DocumentType: OleVariant;
Application:variant;
begin
Application:= CreateOleObject(‘Word.Application’);
DocumentType:=wdNewWebPage;
Application.Documents.Add(EmptyParam,False,DocumentType,EmptyParam);

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

Открытие существующего документа Word реализуется методом Open.
Синтаксис метода:

Open (FileName, ConfirmConversions, ReadOnly, AddToRecentFiles, PasswordDocument, PasswordTemplate, Revert, WritePasswordDocument, WritePasswordTemplate, Format, Encoding, Visible)

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

Если в значении этого параметра указать значение True, то в случае открытия документа с форматом, отличного от Word, будет выводится диалоговое окно конвертирования файла. Необязательный параметр.

Указывая True , открываем документ только для чтения. Необязательный параметр.

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

Пароль открываемого документа. Необязательный параметр.

Пароль открываемого шаблона. Необязательный параметр.

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

Пароль для сохраняемого документа. Необязательный параметр.

Пароль для сохраняемого шаблона. Необязательный параметр.

Конвертор файла, необходимый для открытия документа. Может принимать одно из следующих значений типа WdOpenFormat : wdOpenFormatAllWord , wdOpenFormatAuto , wdOpenFormatDocument , wdOpenFormatEncodedText , wdOpenFormatRTF , wdOpenFormatTemplate , wdOpenFormatText , wdOpenFormatUnicodeText , or wdOpenFormatWebPages . По умолчанию wdOpenFormatAuto . Необязательный параметр.

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

Устанавливая True , предусматриваем видимое открытие документа. По умолчанию установлено True . Необязательный параметр.

Например, для открытия документа «c:\Example.doc» метод Open применяется как

Application.Documents.Open(‘c:\Example.doc’);

а для файла «C:\Exam.doc» с паролем на открытие «1» как:

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

Обращение к документу

Обращение к открытому документу, как к элементу набора коллекции, можно по порядковому номеру методом Item. Например, обращение ко второму документу будет выглядеть как:

Нумерация всех элементов в коллекции начинается с единицы, а не с нуля.

Аналогичную операцию можно осуществить еще как.

Application.Documents(2);

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

Application.Documents.Item(2).Activate;

или по имени файла:

Application.Document(«C:\Example.doc»).Activate;

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

Application. ActiveDocument.Close;

3) Внесение изменений в документы.

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

Суть иерархии следующая: объект Application содержит коллекцию документов Documents , тот в свою очередь содержит коллекцию Paragraphs (абзацев), областей документа Range , таблиц Table , закладок Bookmark.

Вставка текста в документ

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

выражение .Range (начало области, конец области)

например, объявленный ниже объект Range1 охватывает собой первые 10 символов второго документа.

var
Range1: variant;
begin
Range1:= Application.Documents(2).Range(1,10);
end;

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

var
Range1: variant;
begin
Application. ActiveDocument . Paragraphs.Add;
Range1:=Application.ActiveDocument.Paragraphs.Item(1).Range;
end;

Вставка текста производится двумя методами объекта Range: InsertAfter и InsertBefore.

Спецификация методов проста:

выражение .InsertAfter( текст) этим методом производится вставка текста после начала объекта Range
выражение .InsertBefore( текст) ,а этим — до.

при использовании этих методов, в качестве параметра указать нужно только текст в апострофах. К примеру, вызов двух операторов

Range1.InsertAfter(‘это текст InsertAfter’);
Range1.InsertBefore(‘это вставленный текст InsertBefore’);

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

это вставленный текст InsertBefore
это текст InsertAfter

У объекта Range есть много полезных свойств, которые вам неплохо было бы узнать:

свойство Font (шрифт), которое имеет свои подсвойства:

Font .Bold:=True — жирность шрифта
Font .Name:=»Arial»- название шрифта
Font .Size:= 24 — размер шрифта

Font .Color:= clRed — цвет шрифта

Font .Italic:= True — наклонность шрифта

Например, вставка жирной строки зеленого цвета:

Range1.Font.Bold:= True;
Range1.Font.Size:= 24;
Range1.Font.Size:= clGreen;
Range1.InsertAfter(‘вставленная строка’);

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

Word — Тип Delphi

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

Есть два пути для получения доступа к серверам автоматизации:

Позднее связывание (Интерфейс IDispatch)

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

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

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

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

Раннее связывание (Использование библиотеки типов/интерфейсов)

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

Библиотека типов должна импортироваться в Delphi. Библиотека типов является языковым нейтральным описанием всех объектов и функций, поддерживаемых сервером. (Это подобно файлу заголовка языка C).

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

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

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

Подготовка библиотеки типов.

Модуль Pascal должен быть создан на основе файла библиотеки типов.

  • Выберите пункт меню Project|Import Type Library
  • Нажмите кнопку Add и выберите следующий файл
  • c:\program files\microsoft office\office\msword8.olb
  • Нажмите OK.

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

Наиболее простой путь заключается в следующем: удалите модуль excel_tlb из проекта и только после этого добавьте его в список используемых модулей.

Справочный файл c:\program files\microsoft office\office\vbawrd8.hlp содержит информацию о доступных объектах Word.

«Записыватель» макросов позволяет быстро создавать VBA-код. После этого он довольно может легко быть портирован в Delphi.

Следующий пример использует класс-оболочку Delphi, инкапсулирующий прямые вызовы объектов Word. Вот преимущество этого метода:

  • Обеспечение скрытия параметров. Возможность использования для многих методов параметров по умолчанию. Многие методы Word также работают с вариантными параметрами. Это означает невозможность использования констант — скрытие параметров решает данную проблему.
  • Обеспечение проверки типа. Многие методы определены с параметрами OLEVariant, обеспечивая внешнюю совместимость.
  • Следующий класс-оболочка демонстрирует ключевые методы автоматизации Word. Полностью класс приведен в Приложении 1.

Чтобы создать класс:

Добавьте модуль библиотеки типов в список используемых модулей.

Создадим определение класса:

Переменная App является ссылкой на приложение Word. Это допускает вызов методов Word с применением технологии раннего связывания.

Опубликованные (public) процедуры — процедуры, которые могут быть использованы при работе с классом.

Он вызывается при создании класса TWinWord. CoApplication.create создает новый экземпляр Word и возвращает ссылку на интерфейс Application. Это позволяет вызывать методы объекта app.

Деструктор должен вызываться В ОБЯЗАТЕЛЬНОМ ПОРЯДКЕ. Метод Quit объекта приложения закрывает Word и распределяет всю связанную с ним память. Так как параметры метода Quit определены как вариантный тип OLEVariant, вся свазанная с ними память распределяется именно для этого типа переменных.

Реализуем метод NewDoc. Этот метод создаст новый текстовый документ на основе заданного шаблона.

Данный метод осуществляет более строгую проверку типов, чем это осуществляет сам Word. Параметр Template должен содержать строку с именем шаблона. Метод Word Add в качестве параметров может содержать значения любого типа. Лучшая пример этого — метод MoveRight, реализация которого показана в Приложении 1.

Ниже показана реализация метода SaveAs. Данный метод позволит сохранить в файле текущий документ.

проверяются только во время прогона. Изменение имени метода в этом случае не вызовет ошибку во время компиляции. В нашем случае технология позднего связывания более эффективна, так как метод SaveAs требует 12 параметров, но только параметр FileName является обязательным. Так как данный вызов можно считать единичным, его выполнение не может особо сказаться на скорости выполнения программы.

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

  • Всегда используйте раннее связывание.
  • Если позднее связывание необходимо для вызовов некоторых функций, используйте где возможно раннее связывание и преобразование типа объектной переменной к типу OLEVariant для вызовов, требующим позднее связывание.
  • Не включайте модуль библиотеки типов в ваш проект. Добавьте его только в список используемых модулей.
  • Создавайте код автоматизации в отдельном модуле. Инкапсулируйте вызовы в классе-оболочке.
  • Используйте «записыватель» макросов Word для создания прототипа кода автоматизации.
  • Используйте файл электронной справки vbawrd8.hlp для получения информации об объектах Word.
  • Используйте модуль Word_tlb.pas для проверки необходимых Delphi типов и количества параметров. Для проверки правильности кода перекомпилируйте проект, нажав клавиши .
  • Загружайте и используйте шаблоны Word, содержащие предварительное форматирование текста. Этот способ существенно быстрее и не требует большого времени для создания сложноформатированных документов. Шаблоны ДОЛЖНЫ сохраняться приложением в своей рабочей директории. Это поможет избежать проблем, связанных с конфликтом имен.
  • Используйте закладки (Bookmarks) для определения области ввода текста приложением Delphi.
  • Удостоверьтесь в том, что ваш код содержит команду закрытия приложения Word (app.quit). Не вызывая app.quit, можно быстро исчерпать системные ресурсы, особенно при работе с большим количеством документов Word. Обратите на это особое внимание.
  • Наличие множества незакрытых документов Word легко проверить в Windows NT, используя Менеджер Задач (нажмите CTL+ALT+Del для его открытия).

Приложение A – Полный исходный код сласса TWinWord

Полный исходный код класса tWinWord приведен ниже. Он включает реализацию всех методов:

Word — Тип Delphi

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

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

Место описания данных в программе — вне логических блоков begin / end. В модуле перед ключевым словом implementation есть блок описания:

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

Команда объявления переменных в языке Delphi:

var имя_переменной : тип_переменной ;

Слово var — ключевое. Именем может быть любой идентификатор, если он не был описан ранее и не является одним из ключевых или зарезервированных слов языка Delphi. Если нужно описать несколько переменных одного типа, то их перечисляют, отделяя запятой:

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

Постоянную величину иначе называют константой. Конечно, в программе можно использовать числа и строки непосредственно: 3.1415 или ‘Это значение числа пи’ , но иногда удобнее присвоить их идентификатору. Описание констант аналогично описанию переменных, но используется ключевое слово const, за именем идентификатора следует тип, затем знак равенства и его значение. Причём тип константы допускается не указывать:

const pi= 3.1415 ;
ZnakPi : String = ‘Это значение числа пи’ ;

К слову, константа Pi встроенная в Delphi, то есть для того чтобы использовать в Delphi число 3,1415. в расчётах, нужно просто присвоить встроенную константу Pi переменной типа Real или просто использовать непосредственно в выражениях.

Теперь пришло время узнать о типах данных, используемых в Delphi. Прежде всего это строки и числа.

Строкой называется последовательность символов, заключённая в одиночные кавычки:
‘это текстовая строка’ Если текст должен содержать сам символ кавычки, то его надо повторить дважды:
‘это » — символ одиночной кавычки’ Строка может быть и пустой, не содержащей символов. Тогда она состоит из двух идущих друг за другом без пробела кавычек. Естественно, строка может состоять и только из одних пробелов.
Самый популярный строковый тип — String. Строка типа String может содержать переменное количество символов объёмом до 2 Гбайт. Если нужно ограничить размер строки фиксированным значением, то после ключевого слова String в квадратных скобках указывается число, определяющее количество символов в строке: String[50]. Более полно работа со строками Delphi описывается далее.
Одиночный символ имеет тип Char и записывается в виде знака в одиночных кавычках: ‘a’. Есть символы, которые на экране отобразить невозможно, например, символ конца строки (равен #13), символ переноса строки (равен #10). Такие символы записываются в виде их числового кода (в кодировке ANSI), перед которым стоит знак #. Например, #0.
Наконец, существуют так называемые нуль-терминированные строки. Отсчёт символов в таких строках начинается с нуля, а заканчивается символом с кодом (#0). Такие строки имеют тип PChar.

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

Integer -2147483648 .. +2147483647
Cardinal 0 .. 4294967295
Shortint -128 .. +127
Smallint -32768 .. +32767
Int64 -2 63 .. +2 63 -1
Byte 0 .. +255
Word 0 .. +65535
Наиболее удобным для использования в программах является тип Delphi Integer. Другие целые типы используются для уменьшения места, занимаемого данными в памяти компьютера.

Дробные числа имеют дробную часть, отделяемую десятичной точкой. Допускается использование символа e (или E), за которым следует число, указывающее, что левую часть нужно умножить на 10 в соответствующей степени: 5e25 — пять умножить на десять в двадцать пятой степени.
Ниже приведены стандартные типы дробных чисел и соответствующие им диапазоны допустимых значений. Для большинства типов указан диапазон положительных значений, однако допустимым является аналогичный диапазон отрицательных значений, а также число .

Real 5*10 -324 .. 1.7*10 308
Real48 2.9*10 -39 .. 1.7*10 38
Singl 1.5*10 -45 .. 3.4*10 38
Double 5*10 -324 .. 1.7*10 308
Extended 3.6*10 -4951 .. 1.1*10 4932 -1
Comp -2 63 .. +2 63 -1
Currency 922337203685477.5807
Наиболее удобным для использования в программах является тип Delphi Real. Ему эквивилентен тип Double, но в будущем это может быть изменено. Вычисления с дробными числами выполняются приближённо, за исключением типа Currency (финансовый), который предназначен для минимизации ошибок округления в бухгалтерских расчётах.

Следующим типом данных является логический Boolean, состоящий всего из двух значений: True (Истина) и False (Ложь). При этом True > False.

Теперь, используя компоненты, их свойства и события, вводя собственные переменные, можно конструировать программы, содержащие вычисления. Осталось узнать, как вычисленное значение вывести на экран.
Про консольные программы я здесь не говорю! А в нормальных оконных Windows-приложениях это значение нужно поместить в какой-нибудь компонент, имеющий свойства Text или Caption. Это, например, такие компоненты как Label и Edit, да и сама Форма имеет свойство Caption, куда тоже можно выводить информацию. Однако, в Delphi информацию перед выводом, как правило, необходимо преобразовывать. Так как присвоение возможно только между переменными одного типа, то такая программа (не пытайтесь её исполнять):

var A, B, C: Integer ;
begin
A := 5 ;
B := 10 ;
C := A+B ;
Label1.Caption := C ;
end ;

вызовет ошибку, так как свойство Caption имеет текстовый тип String, а использованные переменные — цифровой тип Integer. Значит, нужно преобразовать значение переменной C в текстовый тип. Для этого есть встроенная функция IntToStr. Строка в нашей «программе», вызывавшая ошибку, должна выглядеть так:

Такая программа, кроме показа числа 15, ни на что не способна. Мы должны научиться вводить в программу другие числа. Используем компоненты Edit. Введённые числа будут содержаться в свойстве Text этих компонентов. Расположим на форме два компонента Edit, один компонент Label и кнопку Button, по нажатию на которую и будем проводить вычисления. В компоненты Edit1 и Edit2 будем вводить числа для суммирования. Чтобы переместиться в редактор кода, щёлкнем дважды по нашей кнопке Button1. Мы попадём прямо в сформированную для нас средой Delphi заготовку обработчика нажатия на кнопку, непосредственно между операторами begin и end. Напишем такой простой код:

procedure TForm1.Button1Click(Sender: TObject);
var A, B, C: Integer; //Не забудьте описание переменных
begin
//Начало кода:
A := Edit1.Text;
B := Edit2.Text;
C := A+B;
Label1.Caption := IntToStr(C);
//Конец кода
end ;

При попытке исполнить этот код Delphi покажет ошибки по аналогичной причине — переменные A и B имеют цифровой тип Integer, а свойство Text — текстовый тип String. Исправить ошибки поможет встроенная функция StrToInt, выполняющая обратное преобразование — текст в целое число. Операторы присвоения переменным A и B должны выглядеть так:

A := StrToInt(Edit1.Text);
B := StrToInt(Edit2.Text);

В данном случае переменные A, B, C использовались для наглядности. Можно обойтись одной строчкой:

Аналогично, имеются функции и для преобразования в строку и обратно действительных чисел c плавающей (Floating англ.) запятой, имеющих тип Real. Для преобразования в строку — FloatToStr, обратно — StrToFloat.
Часто результаты вычислений, имеющие тип Delphi Real, имеют после запятой длинный «хвост» цифр. При выводе такой переменной в текстовом виде необходимо ограничить количество цифр после запятой. Как это можно сделать, описывается также в Уроке Delphi Работа со строками Delphi.

Word — Тип Delphi

Основы Delphi: 4. Операции над целыми числами

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

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

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

Тип Описание Размер памяти Значения
byte Беззнаковое целое 1 байт 0..255
shortint Знаковое целое 1 байт -128..127
word Беззнаковое целое 2 байта 0..65535
smallint Знаковое целое 2 байта -32768..32767
cardinal
longword
Беззнаковое целое 4 байта 0..4294967295
или 0..2 32 -1
integer
longint
Знаковое целое 4 байта -2147483648..2147483647
или -2 31 ..2 31 -1
int64 Знаковое целое 8 байт -9223372036854775808..9223372036854775807
или -2 63 ..2 63 -1
uint64 Беззнаковое целое 8 байт 0..18446744073709551615
или 0..2 64 -1

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

begin
WriteLn( ‘byte: ‘ ,SizeOf(byte));
WriteLn( ‘word: ‘ ,SizeOf(word));
WriteLn( ‘cardinal: ‘ ,SizeOf(cardinal));
WriteLn( ‘uint64: ‘ ,SizeOf(uint64));

Структура целочисленного значения

Для типа byte со структурой все понятно: занимает один байт, от 0 до 255, т.е. от 00000000 до 11111111 в двоичном виде. В структуре числа нет информации о знаке числа, поэтому тип и называется — беззнаковый.

Для знакового типа shortint необходимо сохранять информацию о знаке — для этого достаточно одного старшего (первого слева) бита. Если он равен 0, то число — положительное (или равное нулю) и его значения варьируются от 0 до 127, т.е. от 00000000 до 01111111. Если старший бит равен 1, то число — отрицательно, и оставшиеся 7 бит являются разностью между числом 128 и модулем искомого числа (так называемый дополнительный код числа). Например:

-1 11111111
-2 11111110
-3 11111101
-128 10000000

Остальные целочисленные типы требуют больше, чем 1 байт памяти. Для удобства байты значения в памяти записывают в обратном порядке. Например число 123456 типа integer, которое в двоичном и шестнадцатиричном виде записывается как

в памяти будет представлено в виде

01000000 11100010 00000001 00000000

Чтобы убедиться в том, что байты значения в памяти записываются в обратном порядке можно провести эксперимент. Возьмем у числа 789 (или 0000001100010101) типа word только первый байт, и он должен равняться 21 (или 00010101), а не 3 (или 00000011) при прямом порядке:

begin
A := 789 ;
P := @A; // указатель на область памяти переменной A

WriteLn( A );
WriteLn( PByte(P)^ ); // выводим первый байт области памяти
// на который указывает P
ReadLn;
end .

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

Знак Операция Пример Результат
+ Сложение 7 + 4 11
Вычитание 7 — 4 3
* Умножение 7 * 4 28
/ Деление 7 / 4 1.75 (всегда вещественное)
div Деление без остатка 7 div 4 1 (всегда целое)
mod Остаток от деления 7 mod 4 3

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

Знак Операция Пример Результат
not Отрицание not 5 (¬ 00000101) -6 (11111010)
and Побитовое логическое «И» 5 and 7 (00000101 ^ 00000111) 5 (00000101)
or Побитовое логическое «ИЛИ» 5 or 7 (00000101 v 00000111) 7 (00000111)
xor Побитовое логическое «исключающее ИЛИ» 5 xor 7 (00000101 xor 00000111) 2 (00000010)
shl Сдвиг битов влево 22 shl 2 (00010110) 88 (01011000)
shr Сдвиг битов вправо 22 shr 2 (00010110) 5 (00000101)

Значения одного целочисленного типа приводятся к другому целочисленному типу без каких либо проблем. Следует учесть, что если новый тип занимает в памяти меньше байт, чем старый тип, то лишние байты просто отсекаются. Это также удобно, если необходимо получить первые несколько байт целочисленного значение (например, первый байт значения типа word или первые два байта значения типа cardinal). Однако, если тип значения знаковый, а само значение отрицательное, то приведение к типу, занимающему меньше памяти, может привести к положительному результату. Например, приводя значение -1000 (11111100 00011000) типа smallint к типу shortint, в результате получим 24 (00011000).

Значение результата какой-либо целочисленной операции всегда имеет тип, который занимает в памяти максимум из типов операндов. Например, integer + word = integer, int64 — byte = int64. Это может создать проблемы при операции умножения, когда результат необходимо получить с типом int64. В конструкции

выражение (a * b) имеет тип integer, а не int64, и значение может переполниться. В этом случае следует привести один из операндов к типу int64. Явное приведение к какому-либо типу описывается следующим образом:

В таком случае, текст программы выглядит так:

Перевести тип «Word» в «String»

этот тип данных может содержать только числа, и то, только до 255 (или до — 255)

:) А нам как раз сейчас требуется на работу Хороший программист! :)

Если ты имеешб ввиду word это байт, то да!

Re: Anatoly Podgoretsky :) Отлично! Тогда вам к нам! ))

И кстате, почему ты не поможешь этому парню?

А действительно в станд. поставке Delphi толькодля UTF-8 (1 б.) и UCS4 (4-байт. Unicode)

WideChar characters use more than one byte to represent every character. In the current implementations, WideChar is word-sized (16-bit) characters ordered according to the Unicode character set (note that it could be longer in future implementations).

Простой пример работы с MS Word в Delphi FMX

Вопрос

Pax Beach 249

Pax Beach 249

  • Продвинутый пользователь
  • Пользователи
  • 249
  • 414 сообщения
  • Город Moscow

Сделал пример приложения для работы с Microsoft Word из приложения Delphi.

Такое приложение может использоваться для обмена данными между объектами семейства Microsoft Office.

Исходные коды приложения помогут вам понять, как работать с объектной моделью Microsoft Word.

Чтобы лучше разобраться с нюансами Word, предлагаю ознакомиться со справочником Word VBA reference на MSDN.

Проект создан в среде FireMonkey Delphi Berlin 10.1
Протестирован в MS Word 2010, 2020, Windows 7×64 и 10×64.
Чтобы посмотреть пример, просто распакуйте zip-файл проекта и щелкайте по порядку кнопки на форме.

Изменено 23 января, 2020 пользователем Andrey Efimov
Залил архив на форум, в соответствии с правилами.

Поделиться сообщением

Ссылка на сообщение
Поделиться на другие сайты

21 ответ на этот вопрос

Рекомендуемые сообщения

Присоединяйтесь к обсуждению

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

Simple Types (Delphi)

Contents

Simple types — which include ordinal types and real types — define ordered sets of values.

Ordinal Types

Ordinal types include integer, character, Boolean, enumerated, and subrange types. An ordinal type defines an ordered set of values in which each value except the first has a unique predecessor and each value except the last has a unique successor. Further, each value has an ordinality, which determines the ordering of the type. In most cases, if a value has ordinality n, its predecessor has ordinality n-1 and its successor has ordinality n+1.

For integer types, the ordinality of a value is the value itself. Subrange types maintain the ordinalities of their base types. For other ordinal types, by default the first value has ordinality 0, the next value has ordinality 1, and so forth. The declaration of an enumerated type can explicitly override this default.

Several predefined functions operate on ordinal values and type identifiers. The most important of them are summarized below.

-2147483648..2147483647
(-2 31 ..2^ 31 -1)

-9223372036854775808..9223372036854775807
(-2 63 ..2 63 -1)

0..4294967295
(0..2 32 -1)

0..18446744073709551615
(0..2 64 -1)

-2147483648..2147483647
(-2 31 ..2 31 -1)

-9223372036854775808..9223372036854775807
(-2 63 ..2 63 -1)

0..4294967295
(0..2 32 -1)

0..18446744073709551615
(0..2 64 -1)

Type Platform Range Format Alias
32-bit platforms
64-bit platforms 32-bit platforms
64-bit platforms Unsigned 64-bit UInt64
32-bit platforms and 64-bit Windows platforms
64-bit POSIX platforms include iOS and Linux Signed 64-bit Int64
32-bit platforms and 64-bit Windows platforms
64-bit POSIX platforms include iOS and Linux UInt64

Note: 32-bit platforms include 32-bit Windows, 32-bit macOS, 32-bit iOS, iOS Simulator and Android.

Platform-Independent Integer Types

Platform-independent integer types always have the same size, regardless of what platform you use. Platform-independent integer types include ShortInt, SmallInt, LongInt, Integer, Int64, Byte, Word, LongWord, Cardinal, and UInt64.

Platform-independent integer types

A value of type ByteBool, LongBool, or WordBool is considered True when its ordinality is nonzero. If such a value appears in a context where a Boolean is expected, the compiler automatically converts any value of nonzero ordinality to True.

The previous remarks refer to the ordinality of Boolean values, not to the values themselves. In Delphi, Boolean expressions cannot be equated with integers or reals. Hence, if X is an integer variable, the statement:

generates a compilation error. Casting the variable to a Boolean type is unreliable, but each of the following alternatives will work.

Enumerated Types

An enumerated type defines an ordered set of values by simply listing identifiers that denote these values. The values have no inherent meaning. To declare an enumerated type, use the syntax:

where typeName and each val are valid identifiers. For example, the declaration:

defines an enumerated type called Suit , whose possible values are Club , Diamond , Heart , and Spade , where Ord(Club) returns 0, Ord(Diamond) returns 1, and so on.

When you declare an enumerated type, you are declaring each val to be a constant of type typeName . If the val identifiers are used for another purpose within the same scope, naming conflicts occur. For example, suppose you declare the type:

Unfortunately, Click is also the name of a method defined for TControl and all of the objects in VCL that descend from it. So if you are writing an application and you create an event handler like:

you will get a compilation error; the compiler interprets Click within the scope of the procedure as a reference to a Click method of a TForm. You can work around this by qualifying the identifier; thus, if TSound is declared in MyUnit, you would use:

A better solution, however, is to choose constant names that are not likely to conflict with other identifiers. Examples:

You can use the (val1, . valn) construction directly in variable declarations, as if it were a type name:

But if you declare MyCard this way, you cannot declare another variable within the same scope using these constant identifiers. Thus:

generates a compilation error. But:

compiles cleanly, as does:

Enumerated Types with Explicitly Assigned Ordinality

By default, the ordinalities of enumerated values start from 0 and follow the sequence in which their >

defines a type called Size whose possible values include Small , Medium , and Large , where Ord(Small) returns 5, Ord(Medium) returns 10, and Ord(Large) returns 15.

An enumerated type is, in effect, a subrange whose lowest and highest values correspond to the lowest and highest ordinalities of the constants in the declaration. In the previous example, the Size type has 11 possible values whose ordinalities range from 5 to 15. (Hence the type array[Size] of Char represents an array of 11 characters.) Only three of these values have names, but the others are accessible through typecasts and through routines such as Pred, Succ, Inc, and Dec. In the following example, «anonymous» values in the range of Size are assigned to the variable X .

Any value that is not explicitly assigned an ordinality has the ordinality one greater than that of the previous value in the list. If the first value is not assigned an ordinality, its ordinality is 0. Hence, given the declaration:

SomeEnum has only two possible values: Ord(e1) returns 0, Ord(e2) returns 1, and Ord(e3) also returns 1; because e2 and e3 have the same ordinality, they represent the same value.

Enumerated constants without a specific value have RTTI:

whereas enumerated constants with a specific value, such as the following, do not have RTTI:

Scoped Enumerations

You can use scoped enumerations in Delphi code if you enable the compiler directive.

For instance, let us define the following unit in the Unit1.pas file

and the following program using this unit

First, Run (F9) on this code. The code runs successfully. This means that the First identifier, used in the

variable, is the global scope identifier introduced in the

Now clear comment from the

compiler directive in the unit1 unit. This directive enforces the TMyEnum enumeration to be scoped. Execute Run. The E2003 Undeclared identifier ‘First’ error is generated on the

line. It informs that the <$SCOPEDENUMS ON>compiler directive prevents the First identifier, introduced in the scoped TMyEnum enumeration, to be added to the global scope.

To use identifiers introduced in scoped enumerations, prefix a reference to an enumeration’s element with its type name. For example, clear comment in the second

version of the Value variable (and comment the first version of Value ). Execute Run. The program runs successfully. This means that the First identifier is known in the TMyEnum scope.

Now comment the

compiler directive in unit1 . Then clear comment from the declaration of the First variable

and again use the

variable. Now the code in the program Project1 looks like this:

Execute Run. The

line causes the E2010 Incompatible types — ‘TMyEnum’ and ‘Integer’ error. This means that the naming conflict occurs between the global scope First identifier introduced in the TMyEnum enumeration and the First variable. You can work around this conflict by qualifying the First identifier with the unit1 unit in which it is defined. For this, comment again the first version of Value variable and clear comment from the third one:

Execute Run. The program runs successfully. That is, now the First identifier can be qualified with the unit1 unit scope. But what happens if we again enable the

compiler directive in unit1 . The compiler generates the E2003 Undeclared identifier ‘First’ error on the

line. This means that prevents adding the First enumeration’s identifier in the unit1 scope. Now the First identifier is added only in the TMyEnum enumeration’s scope. To check this, let us again use the

version of the Value variable. Execute Run and the code succeeds.

Subrange Types

A subrange type represents a subset of the values in another ordinal type (called the base type). Any construction of the form Low..High , where Low and High are constant expressions of the same ordinal type and Low is less than High , identifies a subrange type that includes all values between Low and High . For example, if you declare the enumerated type:

you can then define a subrange type like:

Here TMyColors includes the values Green , Yellow , Orange , Purple , and White .

You can use numeric constants and characters (string constants of length 1) to define subrange types:

When you use numeric or character constants to define a subrange, the base type is the smallest integer or character type that contains the specified range.

The LowerBound..UpperBound construction itself functions as a type name, so you can use it directly in variable declarations. For example:

declares an integer variable whose value can be anywhere in the range from 1 through 500.

The ordinality of each value in a subrange is preserved from the base type. (In the first example, if Color is a variable that holds the value Green , Ord(Color) returns 2 regardless of whether Color is of type TColors or TMyColors.) Values do not wrap around the beginning or end of a subrange, even if the base is an integer or character type; incrementing or decrementing past the boundary of a subrange simply converts the value to the base type. Hence, while:

produces an error, the following code:

assigns the value 100 to I (unless compiler range-checking is enabled).

The use of constant expressions in subrange definitions introduces a syntactic difficulty. In any type declaration, when the first meaningful character after = is a left parenthesis, the compiler assumes that an enumerated type is being defined. Hence the code:

produces an error. Work around this problem by rewriting the type declaration to avoid the leading parenthesis:

Real Types

A real type defines a set of numbers that can be represented with the floating-point notation. The table below gives the ranges and storage formats for the real types on 64-bit and 32-bit platforms.

Boolean ByteBool, WordBool, LongBool
Extended
32bit Intel Windows 3.37e-4932 .. 1.18e+4932 10-20 10
64-bit Intel Linux
32-bit Intel macOS
32-bit Intel iOS Simulator
3.37e-4932 .. 1.18e+4932 10-20 16
other platforms 2.23e-308 .. 1.79e+308 15-16 8
Comp all -9223372036854775807.. 9223372036854775807
(-2 63 +1.. 2 63 -1)
10-20 8
Currency all -922337203685477.5807.. 922337203685477.5807 10-20 8

The following remarks apply to real types:

  • Real is equivalent to Double, in the current implementation.
  • Real48 is maintained for backward compatibility. Since its storage format is not native to the Intel processor architecture, it results in slower performance than other floating-point types.

The 6-byte Real48 type was called Real in earlier versions of Object Pascal. If you are recompiling code that uses the older, 6-byte Real type in Delphi, you may want to change it to Real48. You can also use the compiler directive to turn Real back into the 6-byte type.

  • Extended offers greater precision on 32-bit platforms than other real types.

On 64-bit platforms Extended is an alias for a Double; that is, the size of the Extended data type is 8 bytes. Thus you have less precision using an Extended on 64-bit platforms compared to 32-bit platforms, where Extended is 10 bytes. Therefore, if your applications use the Extended data type and you rely on precision for floating-point operations, this size difference might affect your data. Be careful using Extended if you are creating data files to share across platforms. For more information, see The Extended Data Type Is 2 Bytes Smaller on 64-bit Windows Systems.

Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL