Input — Переменная Delphi


Типы переменных Delphi. Глобальные переменные Обучающий материал

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

Глобальные переменные Delphi

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

Следует заметить, что нежелательно использовать в качестве имени переменной счетчик цикла, который затем будет использоваться в программе. Имеется ввиду, что если существует глобальная переменная Delphi “i:Integer”, то эту “i” не нужно использовать в цикле. Такое применение может вызвать замедление цикла и некорректность в работе. К тому же следует помнить, что если нет крайней необходимости в использовании глобальных переменных, то нужно воздержаться от их объявления.

Локальные переменные Delphi

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

Глобальные и локальные типы переменных Delphi чаще всего используется при написании кода. Однако иногда существует необходимость при выполнении того или иного приложения где-то хранить промежуточные данные. Они необходимы именно для внутренних операций и в дальнейшем нигде не используются. В таких случаях целесообразно использовать динамические переменные.

Динамический тип переменных Delphi

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

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

Input — Переменная Delphi

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

Вот список основных типов переменных в Delphi:

  • Integer — целые числа из диапазона: -2147483648..+2147483647
  • Shortin — целые числа из диапазона: -128..+127
  • Byte — целые числа из диапазона: 0..+255
  • Real — как целые так и дробные числа из диапазона: 5e-324..1.7e+308
  • Double — схож с типом Real
  • String — строковый тип данных
  • Char — символьный тип данных
  • Bollean — логический тип данных. Может принимать значение True — истина или False — ложь

С теорией мы закончили, теперь давайте откроем Delphi 7 и создадим новый проект. После этого кидаем на форму знакомый нам компонент Button и еще не знакомый Label. Компонент Label эта такая полезная вещь, в которую можно записать какую-нибудь подпись. Например подпись для другого компонента или просто записать в него автора программы. Попробуйте отыскать компонент Label сами, наводя на все компоненты в вкладке Standard и читая всплывающую подсказку. Кому сложно найти, то это четвертый компонент слева, не считая значка курсора.

Я всё сделал и у меня получилось вот так:

Сейчас нам нужно создать событие OnClick на кнопке, я надеюсь, что вы помните, как это делать.
Переменные объявляются между ключевыми словами procedure и begin. Объявление начинается с ключевого слова var, потом пишется имя переменной и через двоеточие её тип. Заканчивается все как всегда точкой с запятой.

Создадим переменную S типа String в процедуре OnClick: После этого между ключевыми словами begin end присвоим переменной значение равное ‘Моя первая переменная’. Присвоение пишется следующим образом. Пишем имя переменной, оператор присвоения := и значение. Если мы записываем информацию типа String, то информация заключается в одинарные кавычки.

Общий вид: Теперь если скомпилировать программу и нажать на кнопку ничего существенного не произойдет, просто в переменную запишется значение и всё. Попробуем вывести значение из переменной. Делается это также просто как и записывается. Выводить значение мы будем в наш Label.

Синтаксис такой: Разберем этот код подробно. Сначала мы написали Label1, потом пишем точку и в Delphi появляется огромный список со свойствами данного компонента. Можно конечно порыться и отыскать там Caption, но мы будем умнее! Мы, после того как поставили точку, напишем еще букву C и Delphi как бы отсортирует все свойства и найдет все, которые начинаются с буквы C. Первым в списке как раз будет свойство Caption.

Выбираем его из списка и нажимаем на Enter. Заметьте, что мы писали Label1.C, но после того, как нажали Enter, Delphi сам дописал название свойства. Далее опять же идет оператор присвоения и наша переменная.

Вы наверняка спросите: «Зачем же переменная, если можно было написать Label1.Caption:=’Моя первая переменная’;?». Ответ простой. Это нужно затем, что мы изучаем переменные :).
Нет, на самом деле так присваивать тоже можно, но представьте такую ситуацию, что вы написали очень большую, популярную программу и у вас, там в программе, пятидесяти компонентам присваивается одно и тоже значение и вот перед вами встала задача: «Поменять это значение на более универсальное и понятное для пользователя».

Что вы будете делать?

  • В первом случае у вас всем этим компонентам присваивается одна и та же переменная и чтобы изменить всем этим пятидесяти компонентам значение вам просто нужно поменять значение в переменной.
  • Во втором случае вы сидите 20 минут и всё копируете и копируете значение всем пятидесяти компонентам.

Вывод делайте сами.

И так, продолжаем! В общем виде должно быть так: Компилируем нашу программу и нажимаем на Button (батон/кнопку). Сразу же компонент Label вместо Label1 будет показывать Моя первая переменная.

На этом хотелось бы закончить, так как я уже устал писать урок :), но я еще не познакомил вас с типом Integer и как присваивать переменную с таким типом. Вы думаете, что присваивать ее нужно точно так же как и переменную типа String, но вы ошибаетесь.
Дело в том, что свойству Caption вообще у всех компонентов можно присвоить только текстовые значения. Как мы будем присваивать числовой тип если можно только текстовой? Всё проще некуда. Между типами переменных можно как бы переключаться, то есть можно из числового типа сделать текстовой и присвоить его компоненту Label. Этим мы сейчас и займемся.

Для начала нужно начать сначала :). Объявим переменную с именем I и типом Integer, дописав ее к переменной S. Код: Далее присвоим переменной I значение 21. Заметьте, что числовое значение записывается без одинарных кавычек! Теперь присвоим свойству Caption значение переменной I, для этого нужно воспользоваться оператором IntToStr(). Он как бы конвертирует числовой тип в текстовой. В скобках указывается переменная, которую нужно конвертировать.

Общий вид кода: Скомпилируйте программу и вы увидите, что Label будет отображать значение переменной I, то есть 21.

Ну вот и всё! Удачи!
Встретимся в следующем уроке!

Источник: www.thedelphi.ru
Автор: Савельев Александр
Опубликовано: 22 Апреля 2012
Просмотров:

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

Переменные в среде программирования Delphi

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

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

Компилятор автоматически инициализирует глобальные переменные как «пустые». Целочисленные значения устанавливаются равными О. строковые значения равными ‘ ‘. а булевские — равными False. Глобальные значения можно также инициализировать вручную при их объявлении: var х: Integer = 101;

Локальные переменные — это переменные, которые объявлены в процедуре или функции. Объявление локальной переменной выглядит подобно показанному ниже:

procedure Имя Процедуры; var

локальная Переменная_1: Тип Данных;

локальная Переменная_n: Тип Данных; begin end;

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

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

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

Илон Маск рекомендует:  Создание двумерных игр при помощи game api

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

Объявление параметров-значений выглядит следующим образом: procedure Имя Процедуры <Имя Параметра: Тип Данных);

При вызове процедуры и передаче ей значения как параметра-значения процедура получает только копию исходного значения.
4. Разработка программного продукта для предметной области «Работники образовательной организации» с применением языка программирования Delphi

Создаем форму и изменяем необходимые свойства главной формы в окне свойств:

Height — ширина формы;

Width — длина формы;

Caption — название формы.

Добавляем на главную форму необходимые элементы управления:

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

StringGrid – отображение таблицы значений x, y, s.

Label – отображение не редактируемого текста;

Edit – ввод данных для формирования массивов и вывода полученных числовых рядов.

Изменяем свойства добавленного элемента управления StringGrid:

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

Ввод и вывод данных

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

Ввод данных из поля редактирования осуществляется обращением к свойству Text этого поля, т.е. Edit1.Text

Следует иметь в виду, что свойство Техt представляет собой строку.

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

Сообщение – выражение строкового типа.

Заголовок окна сообщения, выводимого процедурой ShowMessage , по умолча­нию совпадает с именем исполняемого файла приложения.


Функция MessageDlg ( const : String , Type , Buttons , Help ): Word – отображает окно сообщения в центре экрана и позволяет получить ответ пользователя. Параметр const содержит текст сообщения.

DelphiComponent.ru — бесплатно видеоуроки по Delphi, статьи, исходники

Базовый файловый ввод-вывод в Delphi

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

Для получения доступа к текстовым файлам служат переменные типа Text:

Прежде чем можно будет приступить к работе с файлом, с помощью процедуры AssignFile его нужно присвоить переменной типа Text. Эта процедура принима­ет два параметра: переменную файла и имя файла.

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

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

При работе с текстовыми файлами процедуре Rewrite необходимо передавать только переменную типа Text:

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

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

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

Листинг 8.1. Запись текста в текстовый файл

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

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

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

Листинг 8.2. Считывание текста из текстового файла

Этот код будет успешно работать до тех пор, пока существует файл data. txt. Если этот файл не существует, программа даст сбой. Во избежание остановки при­ложения при отсутствии файла необходимо выполнять проверку успешности от­крытия файла с помощью процедуры Reset.

Для выяснения наличия ошибок ввода-вывода необходимо непосредственно после вызова процедуры ввода-вывода, такой как Rewrite или Reset, вызвать функцию IOResult. Функция IOResult возвращает результат последней выпол­ненной операции ввода-вывода. Если IOResult возвращает 0, это означает, что операция была выполнена успешно.

Для выполнения проверки ввода-вывода с помощью функции IOResult необхо­димо вначале отключить автоматическую проверку ввода-вывода. Для включения и отключения проверки ошибок ввода-вывода служит директива компилятора SI. Обычно автоматическую проверку ввода-вывода отключают перед вызовом проце­дуры ввода-вывода и снова включают сразу после выполнения этого вызова:

Следующий пример иллюстрирует выполнение проверки ввода-вывода и счи­тывание текста из файла только в случае успешного его открытия.

Листинг 8.3. Проверка ошибок ввода-вывода

Помните, что после обращения к процедуре ввода-вывода функцию IOResult можно вызывать только один раз. Это обусловлено тем, что она сбрасывает ре­зультат выполнения последней операции ввода-вывода в 0. Поэтому, если вызвать функцию IOResult дважды подряд, первое обращение к ней правильно сообщит об ошибке, но второе обращение сообщит (ошибочно), что операция была выпол­нена успешно.

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

Как правило, наиболее рациональный способ считывания текстового файла предусматривает использование цикла while, продолжающего итерации вплоть до достижения конца файла. Следующий пример иллюстрирует копирование со­держимого одного текстового файла в другой с использованиемцикла while not Eof (результаты можно видеть на рис. 8.1).

Листинг 8.4. Копирование текстового файла

Рис. 8.1. Копирование текстового файла

В следующем примере цикл while not Eof в функции GetLineCount исполь­зуется для получения количества строк текстового файла. Полученный результат затем используется в вызове функции SetLength для изменения размера динами­ческого массива.

Листинг 8.5. Загрузка текстового файла в динамический массив

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

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

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

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

Существует несколько различий между текстовыми и типизированными фай­лами:

  • При сбросе типизированного файла в нем можно выполнять считывание и запись (при сбросе текстового файла в нем можно выполнять только считы­вание).
  • При выполнении считывания или записи из типизированного файла необ­ходимо использовать процедуры Read и Write, а не ReadLn и WriteLn.

В листинге 8.6 демонстрируется работу с типизированными файлами.

Листинг 8.6. Работа с типизированными файлами

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

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

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

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

Для считывания и записи данных в нетипизированные файлы применяются процедуры BlockRead и BlockWrite. Объявления этих процедур показаны ниже:

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

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

Приложение, код которого представлен в листинге 8.7, использует процедуры BlockRead и BlockWrite для предоставления пользователю возможности копиро­вания файлов. Приложение также дает пользователю возможность указывать имена исходного и целевого файлов в командной строке, как показано на рис. 8.2.

Илон Маск рекомендует:  Что такое код domdocument &#62;create_element

Рис. 8 .2. Передача параметров приложению

Листинг 8.7. Копирование файлов с помощью процедур BlockRead и BlockWrite

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

Для считывания параметров, переданных приложению, служит функция ParamStr, которая принимает единственный параметр типа Integer — индекс параметра. Если передать этой функции значение О, она возвратит путь и имя файла приложения. Индексы пользовательских параметров, если они переданы, начинаются с 1.

Вначале приложение проверяет, передал ли пользователь два параметра в ко­мандной строке. Если да, то ParamStr (1) содержит путь к исходному файлу, а ParamStr (2) — путь к файлу назначения.

Копирование выполняется в процедуре BlockCopyFile.

Ее первая строка:

использует функцию LowerCase для временного преобразования имен обоих фай­лов в строчные буквы и проверяет, указывают ли оба имени файлов на один и тот же файл. Если файл назначения и файл-источник совпадают, никакое копирова­ние не требуется и оператор if-then вызывает процедуру Exit для выхода из про­цедуры.

Основная часть процедуры BlockCopyFile — цикл while, который вызывает процедуры BlockRead и BlockWrite:

Процедура BlockRead считывает из файла 1 Кбайт данных, записывает эти данные в массив Buffer и обновляет переменную BytesRead, которая всегда со­держит точное количество переданных байтов. Выполнение цикла будет повто­ряться до тех пор, пока процедура BlockRead продолжает считывать данные из файла. Когда эта процедура достигнет конца файла, значение переменной BytesRead будет сброшено в 0, условие цикла while станет ложным и копирова­ние файла завершится.

Ввод вывод данных в дельфи

Ввод и вывод данных в среде Дельфи

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

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

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

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


EDIT — однострочный редактор для ввода, вывода и модификации данных

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

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

STATICTEXT — метка, для размещения надписей в рельефной рамке

STRINGGRID — таблица строк, используется для ввода/вывода данных в виде двумерной таблицы.

Каждый компонент получает свое имя (имя компонента и номер, например EDIT1 – первый однострочный редактор, размещенный на форме, EDIT2 — второй однострочный редактор, размещенный на форме и т.д.)

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

Имя компонента Свойство для ввода/вывода

EDITTEXT (в программе записывается EDIT1.TEXT)

MEMOTEXT (в программе записывается MEMO 1.TEXT)

LABEL CAPTION (только вывод) (LABEL1.CAPTION)

STATICTEXT CAPTION (только вывод) (STATICTEXT1.CAPTION)

STRINGGRID массив CELLS [номер столбца, номер строки] в программе записывается STRINGGRID1.CELLS[ j,i ]

Для компонента MEMO часто используется свойство «строка» LINES в сочетании с методом «добавить» ADD. ( в программе записывается MEMO1.LINES.ADD ( ) ).

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

при вводе надо перевести данные из строкового типа в числовой, а именно в целочисленный тип или вещественный тип с помощью функций STRTOINT ( ) или STRTOFLOAT ( );

при выводе данные надо перевести из целочисленного или вещественного типа в строковый с помощью функций INTTOSTR ( ) или FLOATTOSTR ( )

Для выполнения этих операций используется оператор присваивания « := »языка Паскаль.

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

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

Для многострочного редактора существует несколько способов вывода данных:

— способ 1 Memo1.Text := ‘вывод с потерей всего выведенного ранее’;

— способ 2 Memo1.Text := Memo1.Text + ‘вывод с сохранением выведенного ранее’;

— способ 3 Memo1.Lines.Add (‘ добавить строку и вывести все, что в апострофах‘) ;

Способы 1 и 2 не вводят новой строки.

  1. Вывод в поле метки 1 слова Москва Label1.Caption := ‘ Москва ‘;
  2. Вывод в поле метки 2 числа 25 Label2.Caption := ‘ 25 ‘ ;
  3. Вывод в поле метки 1 числа 10,23 StaticText1 := ‘ 10.23 ‘ ;
  4. Ввод в переменную А числа 5 из компонента Edit1 А:= strtoint(Edit1.Text)
  5. Вывод в поле Memo1 значения переменной А Memo1.Text :=inttostr (A) ;

Если выполнить вывод в поле Memo1 из компонента Edit1, то записывается команда Memo1.Text := Edit1.Text

— компонент Edit1

    Ввод в переменную массива В[i,j] целочисленного значения из ячейки StringGrid1

B [ i,j ] :=StrToInt ( StringGrid1.Cells[ j,i ] );

Организация вывода элементов одномерного массива

Элементы одномерного массива можно вывести в разные компоненты.

StaticText1.Caption := StaticText1.Caption + IntToStr (A[I]) + ‘ ‘;

4. Вывод в компонент Memo

Text компонента Memo>

добавление новой строки в список>

5. Вывод одномерного массива Sum в столбец № 1 ком-та s tringgrid1

for i := 1 to m do

В строку № 1 компонента Stringgrid :

for j := 1 to n do

Организация вывода элементов двумерного массива

1. Вывод матрицы В в s tringgrid2

for i := 1 to m do

for j:=1 to n do stringgr >

2. Вывод матрицы В в компонент Memo с расчетом позиций чисел и в файл ‘ d:\ rez. txt’

d,p,z,i,j:integer; // позиции, счетчик пробелов, длина числа

ss,aa :string; // промежуточные строки ss –строка матрицы ;

// аа-строка для числа

assignfile ( ff,’ d:\ rez. txt’); // связь с файлом на диске

rewrite ( ff); // открыть файл для записи

d:=8; // 8 позиций на число

memo2.Lines.Add(‘матрица В’) ; // вывод в memo2

writeln( ff,’матрица В’) ; // вывод в файл

for I:=1 to m do begin

Begin aa:= floattostr (b[i,j]); //расчет длины числа и добавление пробелов

Применение перечисляемых типов Delphi.

Конечно этот пост не вызовет особого интереса у «акул шоубиза Delphi-кодинга», но блог ведь читают и те кто только пробуют разобраться в Delphi и создать что-то свое. Поэтому, думаю, что для таких людей пост «Применение перечисляемых типов Delphi» поможет сделать их приложения более…профессиональными что-ли :).
Не так давно, вдохновленный переводами Александра Божко статей о новом RTTI Delphi 2010 я решил засунуть свою лень поглубже..в портмоне и начать наконец-то разбираться с тем, что такое RTTI, как использовать и т.д. Вообще тема RTTI достаточно обширна и интересна, но сегодня речь пойдет о применении возможностей RunTime Type Information при работе с перечисляемым типом данных. А чтобы не останавливаться на голой теории, рассмотрим применим наши новые знания на практическом примере.

Итак, что такое RTTI.
Runtime Type Information или сокрашенно RTTI (информация о типах времени исполнения) —это данные, генерируемые компилятором Delphi об объектах программы. RTTI представляет собой возможность языка, обеспечивающее приложение информацией об объектах (имя, размер экземпляра, указатели на класс-предок, имя класса и т. д.) и о простых типах во время работы программы. Delphi, например, использует RTTI для доступа к значениям свойств компонент, сохраняемых и считываемых из dfm-файлов и отображения их в Object Inspector.
Основополагающие определения типов, основные функции и процедуры для работы с runtime информацией находятся в модуле TypInfo. Этот модуль содержит две фундаментальные структуры для работы с RTTI — TTypeInfo и TTypeData (типы указателей на них — PTypeInfo и PTypeData соответственно). Попробуем использовать их на конкретном примере.
Допустим, нам необходимо сформировать строку-запрос к тому же Google, чтобы получить доступ к API. Что мы можем почерпнуть из документации по ClientLogin?
1. Это то, что такие параметры как AccountType и Service могут принимать вполне конкретные значения, которые можно представить в виде двух перечисляемых типов данных:

2. Ответ сервера также может содержать ограниченное количество значений (кодов) ошибок и 1 значение («Ok») при успешной аутентификации. Следовательно получим ещё один тип данных:

Теперь, когда все перечисляемые типы данных определены, возникает простой вопрос «Что дальше?». Как бы мы поступили, например, при формировании строки запроса, если б абсолютно ничего не знали про RTTI и модуль TypInfo в частности?
Как минимум, мы бы организовали, что-то наподобие этого:

Примерно то же самое и в отношении TServices. Будет ли этот код работать? Конечно будет…куда он нафиг денется. Но ведь можно сделать и по другому.
В модуле TypInfo определен следующий метод:

Позволяет получить значение перечисляемого типа в виде простой строки. Первый параметр — указатель на запись TTypeInfo, второй — порядковый номер значения в перечисляемом типе данных.
То есть выполнив следующий код:


Мы получим сообщение, содержащее строку «HOSTED». Теперь применив этот метод, мы можем сократить код представленный выше всего до одной строки:

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

Input — Переменная Delphi

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

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

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

Илон Маск рекомендует:  Что такое код openssl_pkcs7_sign

С помощью переменных этого типа очень удобно строить логику. Переменная булева типа может принимать только одно из двух значений – true или false. Лучше и понятнее булевы переменные называть логическими переменными. Для объявления логических переменных используется слово Boolean. Рассмотрим пример работы с такими типами переменных:

В этом примере объявляются две переменные: b (логическая) и str (строковая). Потом происходит присваивание переменной b значения true. Дальше требуются пояснения, потому что идет логическая конструкция if … then, которая до этого момента не изучалась.
Слово if переводится как «если». Слово then переводится как «то». В результате получается конструкция «если условие выполнено,то» В программе она выглядит как if условие выполнено then. Частым случаем этой конструкции является запись if . then . else. Слово else переводится как «иначе». То есть если условие выполнено, то выполнится то, что написано после then, иначе выполнится то, что написано после else.
Все операторы в Delphi заканчиваются точкой с запятой. Это нужно делать, чтобы отделить команды друг от друга, ведь одна команда может быть записана на две строки или две команды в одной. Так вот после оператора, идущего перед else, никогда не ставится точка с запятой. Это правило нужно запомнить.
В примере ниже проверяется условие, если переменная b равна true, то переменной str присваивается значение «Истина», иначе значение «Ложь».

Типы переменных Delphi. Глобальные переменные Обучающий материал

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

Глобальные переменные Delphi

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

Следует заметить, что нежелательно использовать в качестве имени переменной счетчик цикла, который затем будет использоваться в программе. Имеется ввиду, что если существует глобальная переменная Delphi “i:Integer”, то эту “i” не нужно использовать в цикле. Такое применение может вызвать замедление цикла и некорректность в работе. К тому же следует помнить, что если нет крайней необходимости в использовании глобальных переменных, то нужно воздержаться от их объявления.

Локальные переменные Delphi

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

Глобальные и локальные типы переменных Delphi чаще всего используется при написании кода. Однако иногда существует необходимость при выполнении того или иного приложения где-то хранить промежуточные данные. Они необходимы именно для внутренних операций и в дальнейшем нигде не используются. В таких случаях целесообразно использовать динамические переменные.

Динамический тип переменных Delphi

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

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

Ввод и вывод информации в Delphi.

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

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

1. ввод исходных данных;

2. вычисление требуемой величины;

3. вывод результата.

Соответствующая этим этапам блок-схема линейного алгоритма будет следующей:

Рис. 62 Блок-схема линейного алгоритма

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

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

Таблица 9. Функции преобразования

Функция Значение функции
IntToStr (x) Преобразует целое число в строку символов.
StrToInt (x) Преобразует строку символов в целое число.
FloatToStr (x) Преобразует вещественное число в строку символов.
StrToFloat (x) Преобразует строку символов в вещественное число.
FloatToStrF(x, f, k, m) Преобразует вещественное число в строку символов в соответствии с указанными параметрами: f – формат (способ изображения); k – точность (нужное количество цифр); m – количество цифр после десятичной точки
Chr (x) Возвращает символ, соответствующий ASCII коду числа х.

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

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

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

Создадим графический интерфейс окна по образцу, изображенному на рис. 63. Для этого поместим на форму текстовое поле TEdit, кнопку TButton и 2 надписи TLabel. Удалим содержимое свойства Text у компонента Edit1. У надписи Label1 запишем в свойстве Caption сообщение «Введите скорость в км/ч». Для кнопки Button1 введем заголовок «Пересчет».

Рис. 63 Графический интерфейс окна

Исходные данные – скорость в км/ч – будем вводить в текстовое поле Edit1. Результат перевода выведем в надпись Label2.

В данном проекте можно выделить следующие этапы линейного алгоритма:

1. Ввести в поле Edit1 скорость в км/ч.

2. Перевести скорость из км/ч в м/с.

3. Вывести в надпись Label2 скорость в м/с.

Рассмотрим каждый этап линейного алгоритма.

1. Для обозначения исходной скорости в км/ч введем дополнительную переменную целого типа V1. Присвоим переменной V1 значение свойства Text компонента Edit1.

Однако такая запись является неверной, так как типы данных до и после знака присваивания не совпадают: переменная V1 целого типа, а свойство Text компонента Edit1 имеет строковый тип данных. Чтобы далее производить вычисления с вводимыми в поле Edit1 цифрами, которые пока воспринимаются программой как текст, необходимо преобразовать их в числовой формат. В данном случае необходимо использовать функцию StrToInt (преобразует строку в целое число). Таким образом, текст команды ввода будет иметь следующий вид:

V1:= StrToInt (Edit1.Text);

2. Чтобы перевести скорость из км/ч в м/с нужно умножить значение скорости на 1000 и разделить 3600 (в 1 километре – 1000 метров, в 1 часе – 3600 секунд). Введем еще одну переменную V2 для обозначения скорости в м/с. Таким образом, для расчета скорости в м/с используется следующий оператор:

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

3. Для вывода полученной скорости предназначен компонент Label2. Поэтому необходимо свойству Caption компонента Label2 присвоить значение переменной V2:

Данная запись опять нарушает соответствие типов данных, так как в свойстве Caption у надписи могут отображаться только данные символьного типа, а переменная V2 – это вещественное число. Поэтому необходимо преобразовать переменную V2 вещественного типа в строку функцией FloatToStr (преобразовать вещественное число в строку). Текст команды вывода будет выглядеть следующим образом:

При выводе результата часто к полученным значениям добавляют комментарии. Например, в данном проекте можно к значению скорости добавить запись её единиц измерения ‘м/с’. В программе эта запись указывается в одиночных кавычках (апострофах), т.к. является символьной константой. Таким образом, вывод результата может иметь следующий вид: Label2.Caption:= FloatToStr(V2)+ ‘м/с’;

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

В данном случае опишем переменные как локальные внутри процедуры TForm1.Button1Click. Для этого после заголовка процедуры введем раздел описания переменных, который открывается зарезервированным словом var. Описание переменных будет выглядеть так:

var V1: integer; V2: real;

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

procedure TForm1.Button1Click(Sender: TObject);
var V1: integer; V2: real;
begin
V1:= StrToInt (Edit1.Text);
V2:= V1*1000/3600;
Label2.Caption:= FloatToStr(V2) + ‘м/с’;
end;

Рис. 64 Работающее приложение

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

procedure TForm1.Button1Click(Sender: TObject);
begin
Label2.Caption:= FloatToStr((StrToInt (Edit1.Text))*1000/3600) + ‘м/с’;
end

Чтобы программа была готова к вводу новых данных, нужно очистить текстовое поле и поместить в него курсор. В Delphi для этого применяются методы:

Clear (Очистить)

SetFocus (Передать фокус ввода)

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

Последнее изменение этой страницы: 2020-01-25; Нарушение авторского права страницы

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