Double — Тип Delphi


Double — Тип Delphi

В базу данных MySQL записываю некие данные типа Double (поля в базе данных также определены как Double). Запись в БД, как водится идёт через SQL запрос (строкой PChar). Соответственно все данные типа Double перед занесением в БД делаю FloatToStr(). В дальнейшем данные из БД должны сравниваться с данными из программы. Соответственно при получении данных из БД приходится делать StrToFloat из PChar, а затем производить сравнение:

Проблема в том, что даже при одинаковых значениях в DoubleFieldFomDB и DoubleVariableFromProgram (к примеру, 1.2761000395 – смотрю в Watch List) Delphi думает, что они разные и выполняет else… .

P.S. Для работы с MySQL использую библиотеку _LibMysq, компоненты не предлагать.

От: Rius
Дата: 25.05.06 07:58
Оценка:
От: alex_ant
Дата: 25.05.06 08:07
Оценка:

Здравствуйте, Rius, Вы писали:

R>с дуба рухнули? когда это числа с плавающей точкой сравнивались через == ?

Во-первых, не «==», а «=», речь идёт об Object Pascal. Во-вторых, а как тогда ещё сравнивать? Ответьте, пожалуйста, по существу.

От: vladpol http://vlad-mislitel.livejournal.com/
Дата: 25.05.06 08:08
Оценка: 3 (1)

Здравствуйте, alex_ant, Вы писали:

_>В базу данных MySQL записываю некие данные типа Double (поля в базе данных также определены как Double). Запись в БД, как водится идёт через SQL запрос (строкой PChar). Соответственно все данные типа Double перед занесением в БД делаю FloatToStr(). В дальнейшем данные из БД должны сравниваться с данными из программы. Соответственно при получении данных из БД приходится делать StrToFloat из PChar, а затем производить сравнение:
_>
_>Проблема в том, что даже при одинаковых значениях в DoubleFieldFomDB и DoubleVariableFromProgram (к примеру, 1.2761000395 – смотрю в Watch List) Delphi думает, что они разные и выполняет else… .

_>В чём проблема?

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

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

if abs(DoubleFieldFomDB — DoubleVariableFromProgram) Re[2]: Неверное сравнение чисел типа Double в Delphi

От: alex_ant
Дата: 25.05.06 08:20
Оценка:

Здравствуйте, vladpol, Вы писали:

V>Проблема, в том что вещественные числа в двоичный код «точно» не переводятся, особенно периодические дроби, и к ним применяется «обрезание», которое может давать не стабильные резульаты. В итоге Ваши два числа млгут отличаться на один бит в самом конце.

V>if abs(DoubleFieldFomDB — DoubleVariableFromProgram)

Спасибо огромное! Про «обрезание» дробей слышу впервые. Ещё раз спасибо!

А число 0.000000000001 выбрано примерно или это наиболее отимальное значение для Double?

От: Rius
Дата: 25.05.06 08:40
Оценка:

Здравствуйте, alex_ant, Вы писали:
_>Спасибо огромное! Про «обрезание» дробей слышу впервые. Ещё раз спасибо!
я в шоке

_>А число 0.000000000001 выбрано примерно или это наиболее отимальное значение для Double?
нет, подберите для себя оптимальное, с учетом того, какие числа используются

в билдере есть такие функции:

в дельфи тоже должны быть

От: vladpol http://vlad-mislitel.livejournal.com/
Дата: 25.05.06 08:52
Оценка: 3 (1)

Здравствуйте, alex_ant, Вы писали:

_>А число 0.000000000001 выбрано примерно или это наиболее отимальное значение для Double?

От: Аноним
Дата: 26.05.06 16:18
Оценка:

Итак, все мы в свое время обнаруживали, (а если нет — то вас еще ждет это волнующее открытие), что 0.1 в компьютере не равно 0.1

_>Спасибо огромное! Про «обрезание» дробей слышу впервые. Ещё раз спасибо!

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

Для примера, полпробуйте точно записать 1/3 в ДЕСЯТИЧНЫХ дробях числом с не более чем 10 знаками.
Теперь подумайте, как сможет компьютер 1/10 записать в ДВОИЧНЫХ дробях с не более чем 4*8 или 8*8 uлu 10*8 знаками ?

_>А число 0.000000000001 выбрано примерно или это наиболее отимальное значение для Double?

Оптимального для Double не может быть — может быть оптимальное для вашей программы — это можете определить только вы ,зная какая у вас задача и насколько точные нужны данные.
От компьютера есть только минимальная точность (машинный эпсилон), и он НЕ ВЫРАЖАЕТСЯ в абсолятных числах, а только как процент от абсолятной величины числа.

Double — Тип 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.

Типы данных в Delphi Обучающий материал

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

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

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

Целочисленный тип данных в Delphi представлен:

  • Shortint — занимает в памяти 8 битов и имеет числовой диапазон от -127 до 128.
  • Smallint — числовой интервал находится в пределах -32 768 — 32 767 (16 битов).
  • Longint – диапазон чисел от -2 147 483 648 до 2 147 483 647 (32 бита).
  • Int64- наибольший интервал от – 263 до 263-1 (64 бита).
  • Byte- интервал значений от 0 до 255 (8 бит).
  • Word- числовой диапазон от 0 до 65535 (16 бит).
  • Longword –интервал составляет 0 — 4 294 967 295 (32 бита).

Следует заметить, что последние 3 типа называются беззнаковыми так, как имеют в своем числовом интервале только положительные числа( нет отрицательных значений). К тому же можно использовать и тип “Integer”, который соответствует “Longint”. К тому же следует знать, что значения в типах имеют строгий порядок. Такое положение позволяет использовать по отношению к значениям различные процедуры и функции. Не относится к вещественному типу данных в Delphi(не упорядочен).

Числа с плавающей точкой (дробные) представлены в delphi вещественным типом. Вещественный тип данных делится на 6 типов, которые отличаются числовым диапазоном, количеством значащих цифр и занимаемой памятью.

  • Single- число может находиться в интервале 1.5 x 1045-3.4х 1038.Объем занимаемой памяти 4 байта.
  • Real48 — числовой диапазон 2.9x-39-1.7×1038 (6 байт).
  • Double — интервал составляет 5.0×10-324 -1.7×10308 (8 байт).
  • Extended — 3.6×10-4951 -1.1 х104932 (10 байт).
  • Comp — диапазон чисел 263+1 – 263-1, занимаемая память 8 байт.
Илон Маск рекомендует:  Скрипт прогноза погоды для сайта на jQuery + Yahoo API

Currency – этот вещественный тип данных называют еще денежным. С его помощью осуществляется реализация различных приложений финансовой тематики. Имеет 53 бита точности и поддержку 4 десятичных мест.

Текстовую информацию(переменные) представляют строковые типы данных в Delphi. Различают 3 типа:

  • Shortstring — длина строки может составлять максимально 255 символов и в памяти размещается статическим методом.
  • Longstring — такой тип данных ограничен лишь объемом динамической памяти.
  • WideString – аналогичен тип Longstring, но каждый символ представлен в Unicode.

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

Синтаксис указания типа переменной в delphi довольно просто. Ряд примеров подтверждает это утверждение:

Язык Delphi является производным от низкоуровневого языка Object Pascal, что позволяет разрабатывать с использованием совместимых компиляторов программы под Linux. Такое положение обеспечивает написание программ, разработку графических интерфейсов, приложений, способных облегчить администрирование linux, насытить систему новым и удобным функционалом.

Типы данных Delphi

Язык Delphi поддерживает семь целых типов данных, описание которых приведено в табл. 3.

Таблица 3. Целые типы

Тип Диапазон Формат
Shortint -128 – 127 8 битов
Smallint -32768 – 32767 16 битов
Longint -2147483648 – 2147483647 32 бита
Int64 -2 63 – 2 63 -1 64 бита
Byte 0 – 255 8 битов
Word 0 – 65535 16 битов
Longword 0 – 4294967295 32 бита

Язык Delphi поддерживает и наиболее универсальный целый тип — Integer, который эквивалентен Longint.

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

Таблица 4. Вещественные (дробные) типы

Тип Диапазон Значащих цифр Байтов
Real48 2.9 x 10 -39 – 1.7 x 10 38 11 – 12
Single 1.5 x 10 -45 – 3.4 x 10 38 7 – 8
Double 5.0 x 10 -324 ­– 1.7 x 10 308 15 – 16
Extended 3.6 x 10 -4951 – 1.1 x 10 4932 19 – 20
Comp -2 63 +1 – 2 63 -1 19 – 20
Currency -9223372036854775808 –9223372036854775807 19 –20

Язык Delphi поддерживает и наиболее универсальный вещественный тип – Real, который эквивалентен Double.

Язык Delphi поддерживает два символьных типа: Ansichar и Widechar:

· тип Ansichar — это символы в кодировке ANSI, которым соответствуют числа в диапазоне от 0 до 255;

· тип widechar — это символы в кодировке Unicode, им соответствуют числа от 0 до 65535.

Язык Delphi поддерживает и наиболее универсальный символьный тип –Char, который эквивалентен Ansichar.

Язык Delphi поддерживает три строковых типа: Shortstring, Longstring и WideString:

· тип Shortstring представляет собой статически размещаемые в памяти компьютера строки длиной от 0 до 255 символов;

· тип Longstring представляет собой динамически размещаемые в памяти строки, длина которых ограничена только объемом свободной памяти;

· тип WideString представляет собой динамически размещаемые в памяти строки, длина которых ограничена только объемом свободной памяти.

Каждый символ строки типа WideString является Unicode-символом. В языке Delphi для обозначения строкового типа допускается использование идентификатора String. Тип String эквивалентен типу Shortstring.

Логическая величина может принимать одно из двух значений True (истина) или False (ложь). В языке Delphi логические величины относят к типу Boolean.

Типы данных Delphi и работа с ними

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

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

Структурные типы. К структурным типам относятся множества, массивы, записи, файлы, классы, интерфейсы.

Целые типы данных. В переменных целых типов информация представляется в виде целых чисел, т.е. чисел не имеющих дробной части.

Таблица 1 Операции над порядковыми типами

Минимальное значение порядкового типа Т

Максимальное значение порядкового типа Т

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

Предыдущее по порядку значение. Для целых выражений эквивалентно Х-1

Следующее по порядку значение. Для целых выражений эквивалентно Х+1

Уменьшает значение переменной на 1. Эквивалентно V := Pred(V)

Увеличивает значение переменной на 1. Эквивалентно V := Succ(V)

8 битов, беззнаковый

16 битов, беззнаковый

32 бита, беззнаковый

Также существует такой тип, как Integer, который эквивалентен типу LongInt. Его диапазон от -2147483648 до 21474836478. Занимает 4 байта в пямяти. Основными являются Integer и Cardinal, так что в большинстве случаев желательно использовать эти типы.

Над целыми данными выполняются все операции, определенные для порядковых типов. Операции над целыми типами:

Возвращает абсолютное целое значение Х

Возвращает целую часть частного деления Х на Y

Возвращает остаток частного деления Х на Y

Возвращает булево True (истина), если Х — нечетное целое, и False (ложь) — в противном случае

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

Количество значащих цифр

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

Таблица 5 Функции действительных типов

Абсолютная величина х

Косинус х (х выражается в радианах, а не в градусах)

Экспоненциальная функция от х

Дробная часть х

Целая часть х. Несмотря на название, возвращает действительное значение (с плавающей запятой), т.е. просто устанавливает нуль в дробной части

Натуральный логарифм от х

Ближайшее к х целое значение. Возвращает значение целого типа. Условие «ближайшее к х» не работает, если верхнее и нижнее значения оказываются равноудаленными (например, если дробная часть точно равна 0,5). В этих случаях Delphi перекладывает решение на операционную систему. Обычно процессоры Intel решают эту задачу в соответствии с рекомендацией IEEE округлять в сторону ближайшего четного целого числа. Иногда такой подход называют «банкирским округлением»

Квадрат х, т.е. X*X

Квадратный корень от х

Целая часть х. В отличие от Int, возвращающей

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

Однобайтовые символы, упорядоченные в соответствии с расширенным набором символов ANSI

Символы объемом в слово, упорядоченные в соответствии с международным набором символов UNICODE. Первые 256 символов совпадают с символами ANSI

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

Таблица 7 Размеры переменных булевых типов

2 байт (объем Word)

4 байт (объем Longint)

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

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

Имя: [нижний_индекс..верхний_индекс] of тип

где: имя — имя массива;

array — зарезервированное слово языка Delphi, обозначающее, что объявляемое имя является именем массива;

нижний_индекс и верхний_индекс — целые константы, определяющие диапазон изменения индекса элементов массива и, неявно, количество элементов (размер) массива;

Double — Тип 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

C Data Type | Object Pascal | Description

LPSTR PAnsiChar; String >pointer

LPCSTR PAnsiChar; String >pointer

DWORD Integer; Whole numbers

BOOL LongBool; Boolean values

PBOOL ^BOOL; Pointer to a Boolean value

Pbyte ^Byte; Pointer to a byte value

PINT ^Integer; Pointer to an integer value

Psingle ^Single; Pointer to a single (floating point) value

PWORD ^Word; Pointer to a 16-bit value

PDWORD ^DWORD; Pointer to a 32-bit value

LPDWORD PDWORD; Pointer to a 32-bit value

UCHAR Byte; 8-bit values (can represent characters)

PUCHAR ^Byte; Pointer to 8-bit values

SHORT Smallint; 16-bit whole numbers

UINT Integer; 32-bit whole numbers. Traditionally,

this was used to represent unsigned integers,

but Object Pascal does not have a true

unsigned integer data type.

PUINT ^UINT; Pointer to 32-bit whole numbers

ULONG Longint; 32-bit whole numbers. Traditionally,

this was used to represent unsigned integers,

but Object Pascal does not have a true

unsigned integer data type.

PULONG ^ULONG; Pointer to 32-bit whole numbers

PLongint ^Longint; Pointer to 32-bit values

PInteger ^Integer; Pointer to 32-bit values

PSmallInt ^Smallint; Pointer to 16-bit values

PDouble ^Double; Pointer to double (floating point) values

LCID DWORD; A local identifier

LANGID Word; A language identifier

THandle Integer; An object handle. Many Windows API functions return a value

of type THandle, which identobject ifies that object within

Windows’internal object tracking tables.

PHandle ^THandle; A pointer to a handle

WPARAM Longint; A 32-bit message parameter. Under earlier versions of Windows,

this was a 16-bit data type.

LPARAM Longint; A 32-bit message parameter

LRESULT Longint; A 32-bit function return value

HWND Integer; A handle to a window. All windowed controls, child windows,

main windows, etc., have a corresponding window handle that

identifies them within Windows’internal tracking tables.

HHOOK Integer; A handle to an installed Windows system hook

ATOM Word; An index into the local or global atom table for a string

Илон Маск рекомендует:  Язык xml просмотр xml документов

HGLOBAL THandle; A handle identifying a globally allocated dynamic memory object.

Under 32-bit Windows, there is no distinction between globally

and locally allocated memory.

HLOCAL THandle; A handle identifying a locally allocated dynamic memory object.

Under 32-bit Windows, there is no distinction between globally

and locally allocated memory.

FARPROC Pointer; A pointer to a procedure, usually used as a parameter type in

functions that require a callback function

HGDIOBJ Integer; A handle to a GDI object. Pens, device contexts, brushes, etc.,

all have a handle of this type that identifies them within

Windows’internal tracking tables.

HBITMAP Integer; A handle to a Windows bitmap object

HBRUSH Integer; A handle to a Windows brush object

HDC Integer; A handle to a device context

HENHMETAFILE Integer; A handle to a Windows enhanced metafile object

HFONT Integer; A handle to a Windows logical font object

HICON Integer; A handle to a Windows icon object

HMENU Integer; A handle to a Windows menu object

HMETAFILE Integer; A handle to a Windows metafile object

HINST Integer; A handle to an instance object

HMODULE HINST; A handle to a module

HPALETTE Integer; A handle to a Windows color palette

HPEN Integer; A handle to a Windows pen object

HRGN Integer; A handle to a Windows region object

HRSRC Integer; A handle to a Windows resource object

HKL Integer; A handle to a keyboard layout

HFILE Integer; A handle to an open file

HCURSOR HICON; A handle to a Windows mouse cursor object

COLORREF DWORD; A Windows color reference value, containing values

for the red, green, and of ;bsp;blue components of a color

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.

  • The Comp (computational) type is native to the Intel processor architecture and represents a 64-bit integer. It is >See Also

    Double — Тип Delphi

    ДОБРОГО ВРЕМЕНИ СУТОК.

    Есть данные 8-байт. Все 4 переменные типа word содержат в себе одно значение с плавающей точкой; (4byte*2=8byte)
    Я знаю что формат этих данных float или real.

    Как присвоить их одной переменной это понятно
    допустим b4 самое старшее слово(2 байта).

    b4*$ffffff+b3*$ffff+b2*$ff+b1=8 байт данных в формате LongWord

    Ув. мастера вопрос:

    Как перевести эти 8 бит данных в формат float или real но с плавающей запятой?
    Есть догадки что через указатели.


    > vodvorezlaya

    Воспользуйся типом Extended

    в delfi приведение типов делается так
    := ВоЧтоПривести(Переменная);

    Самый маленький тип с плавточкой Single занимает 4 байта т.е. в твои 8 байт можно запихнуть 2 переменные Single.

    1:
    var
    pw: array[0..3]of word;
    _pf_pw: array[0..1]of single absolute pw;
    _pd_pw: array[0..0]of double absolute pw;
    2:
    type
    TExplicitCastFloat = packed record
    case byte of
    0: (pw: array[0..3]of word);
    1: (pf: array[0..1]of single);
    2: (pd: array[0..0]of double);
    end;
    3:
    pf[0]:= single((@pw[0])^);
    4:
    move(pw[0], pf[0], sizeof(pf[0]));

    Я нишута не понял.

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

    Поддерживаю Сергей М. © (01.09.06 16:48) [4]

    В Delphi нет типа float, есть single (4 байта). Типы real и double эквивалентны. Занимают 8 байт.

    Если тебе надо «переконвертировать» double в single, то делает ся Очень Просто:

    var
    d : double;
    s : single;
    begin
    d := 18.144; // 8 байт
    s := d; // 18.144; 4 байта
    .
    end;

    Что касается массива (например ARR = array[0..3] of word ), то преобразовать в double можно так:

    d := double(ARR); // лично я сталкивался с ошибками
    или
    d := pdouble(@ARR[0])^;

    НО самый крутой способ, как предложил han_malign © :

    var
    ARR = array[0..3] of word;
    d: double absolute ARR;

    В таком случае ARR и d будут указывать на одну и туже область памяти. Можешь обращаться к массиву, а можешь сразу к double переменной


    > Хрень какая-то .
    >
    > Я нишута не понял.
    >
    > приведи реальное содержимое того что имеется и того что
    > должно получиться в результате

    Народ. Вопрос не в том немного.

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


    > 1:
    > var
    > pw: array[0..3]of word;
    > _pf_pw: array[0..1]of single absolute pw;
    > _pd_pw: array[0..0]of double absolute pw;
    > 2:
    > type
    > TExplicitCastFloat = packed record
    > case byte of
    > 0: (pw: array[0..3]of word);
    > 1: (pf: array[0..1]of single);
    > 2: (pd: array[0..0]of double);
    > end;
    > 3:
    > pf[0]:= single((@pw[0])^);
    > 4:
    > move(pw[0], pf[0], sizeof(pf[0]));

    Я понял, ты шаришь. А можна с небольшим комментарием.
    Спасибо.


    > 1:
    > var
    > pw: array[0..3]of word;

    А где младший и где старший розряды?


    > В шестнадцатеричных кодах нет знака запятой, она содержится
    > в первых розрядах типа данных Real

    type
    PExtended = ^Extended;
    ..

    var
    MyArray: array[0..3] of Word;
    MyFloatValue: Extended;
    ..
    MyFloatValue := PExtended(@MyArray)^;

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


    > Я понял, ты шаришь. А можна с небольшим комментарием.
    > А где младший и где старший розряды?

    — а вот это уже зависит от способа кодирования битового потока, big-endian(встречается, так же, как — network order, для значений выровненных на размер октета), или little-endian(«обычное» представление для семейства x86 процессоров). В случае little-endian, если данные выровненны на размер октета — никаких дополнительных действий для разбора потока делать не надо — достаточно прямого приведения.
    Что находится в самом битовом потоке — целиком и полностью на совести разработчика — если известно, что это стандартный double — нам не важно где у него мантисса, а где знак, нам важно заполнить 64-бита переменной типа double — 64-мя битами из потока, в соответсвии с правилами кодирования битового потока.
    Выше, я, как раз, привел четыре способа прямого отбражения little-endian значений на разные типы данных.


    > 1:
    > var
    > pw: array[0..3]of word;
    > _pf_pw: array[0..1]of single absolute pw;
    > _pd_pw: array[0..0]of double absolute pw;

    А эти способы разные?

    Потому что первый не сработал.

    han_malign какую литературу ты читал?

    Там у меня вообще передача с контроллера Siemens Simatic S5 там какой то свой формат.

    Как попробовать разными способами кодирования big-endian и little-endian.
    > Ерунда какая-то)

    Слушай han_malign, он шарит?


    > vodvorezlaya (04.09.06 12:38) [12]


    > Слушай han_malign, он шарит?


    > передача с контроллера Siemens Simatic S5

    А ты что не знаеш протокола передачи? Ты используеш OPC сервер?


    > А ты что не знаеш протокола передачи? Ты используеш OPC
    > сервер?

    Нет, я написал сам модуль который по ком порту (через токовый преобразователь) передаёт данные к S5, могу код привести
    :)
    А что такое ОРС сервер?
    Там что, дрова на Симатик есть?


    > vodvorezlaya

    Для работы с контроллерами я всегда использую OPC сервер. Как правило с ним поставляется диск с дровами и OPC сервером, через который моя прога коннектиттся к устройству.Это программа-прослойка. Этот сервер сам преобразует данные получаемые с контроллера по нужному протоколу. я правда не знаю поставляет ли Сиеменс такие веши. Wago, ICPCon и подобные поставляют. ИМХО Самому писать протоколы (тем более к Семену) геморрой.

    http://www.runmode.com/usefulstuff.html
    :
    Notes on Simatic data storage
    * Whenever you need to read or store values on Siemens PLCs, you must be aware that SIMATIC systems adopted the Big Endian byte order, see a brief description here: http://www.cs.umass.edu/

    verts/cs32/endian.html
    там же ссылки на протокол:
    http://www.runmode.com/usefulstuff_files/AS511protocol_description.pdf
    http://www.runmode.com/usefulstuff_files/0141_as511_komponente.zip

    компонент правда на немецком, но это мелочи.


    > ИМХО Самому писать протоколы (тем более к Семену) геморрой.

    2 дня заняло написание полноценного модуля (не драйвера)


    > http://www.runmode.com/usefulstuff.html
    > :
    > Notes on Simatic data storage
    > * Whenever you need to read or store values on Siemens
    > PLCs, you must be aware that SIMATIC systems adopted the
    > Big Endian byte order, see a brief description here: http:
    > //www.cs.umass.edu/

    verts/cs32/endian.html
    > там же ссылки на протокол:
    > http://www.runmode.com/usefulstuff_files/AS511protocol_description.
    > pdf
    > http://www.runmode.com/usefulstuff_files/0141_as511_komponente.
    > zip

    У меня там другой протокол, но похоже
    у меня RK-512


    > 2 дня заняло написание полноценного модуля

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

    Слушай,
    > Elen

    как решить проблему := inttostr(Edit1.Text); не проходит, ошибку какую — то лепис


    > := inttostr(Edit1.Text); не проходит, ошибку какую — то
    > лепис

    Начали за здравие, закончили заупокой)


    > vodvorezlaya

    А ты когда нибудь контроллерами занимался или новичок в этом деле?
    (заодно Делфи подучи inttostr(Edit1.Text) это уже перегрев на работе)


    > У меня там другой протокол, но похоже у меня RK-512

    — да по барабану какой протокол, кодирование потока редко менятся. Но тут есть два варианта, либо они целиком 8 байт double переворачивают, либо пословно(из описания непонятно).
    function ntod(pw: PWord; fFullSwap: boolean): double;
    var __pw: array[0..sizeof(Result)div 2 — 1]of word absolute Result;
    i: integer;
    begin
    if(fFullSwap)then begin
    for i:= Low(__pw) to High(__pw) do begin
    __pw[High(__pw)-i]:= Swap(pw^);
    inc(pw);
    end;
    end else begin
    for i:= Low(__pw) to High(__pw) do begin
    __pw[i]:= Swap(pw^);
    inc(pw);
    end;
    end;
    end;
    — но это если предполагать что там гарантированно стандартный double.


    > это уже перегрев на работе

    Так и есть.

    > А ты когда нибудь контроллерами занимался или новичок в
    > этом деле?

    Каждый день симатик глаза мозолит, немного шарю в Step7.


    > vodvorezlaya

    Сочувствую. Мне с ICPcon попроще. и стоит он дешевле

    Double — Тип Delphi

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

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

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

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

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

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

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

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

    Таблица. Типы целочисленных переменных

    Название

    Размер памяти для хранения данных

    Илон Маск рекомендует:  Dreamweaver CS 5 описание
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL