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

Функции и процедуры Delphi. Справочник.

Функция FloatToStrF(
Value: Extended;
Format: TFloatFormat;
Precision, Digits: Integer ): string;

type TFloatFormat =
(ffGeneral, ffExponent, ffFixed, ffNumber, ffCurrency);

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

Тип Precision Тип Precision Тип Precision
Single =0.00001. В противном случае, применяется научный формат, а параметр Digits определяет минимальное число цифр в экспоненте (0.. 4).
ffExponent Научный формат. Число преобразуется в строку формата
«-x.xxx…E+xxxx». Строка начинается со знака «-» (если число отрицательное). Десятичной точке всегда предшествует одна цифра. Параметр Precision определяет общее количество десятичных цифр, стоящих до символа экспоненты «E» (включая цифру слева от десятичного разделителя). За символом экспоненты следует знак плюс или минус и до 4 цифр, определяющих степень экспоненты. Минимальное число цифр в экспоненте указывается в параметре Digits.
ffFixed Фиксированный формат. Значение преобразуется в строку вида «-ххх.ххх…». Если число отрицательное, то впереди строки будет поставлен знак «-«. Десятичной точке всегда предшествует минимум одна цифра. Количество значащих цифр после десятичной точки (0…18) указывается в параметре Digits. Если количество разрядов слева от разделителя превышает значение, указанное в параметре Precision, то для форматирования будет использоваться научный формат (ffExponent).
ffNumber Числовой формат. Значение будет преобразовано в строку следующего вид «-х,ххх,ххх.ххх…». Данный формат аналогичен формату ffFixed, за исключением того, что полученная строка будет содержать еще и разделители тысяч.
ffCurrency Денежный формат. Значение преобразовывается в строку, представляющую денежную величину. Количество значащих цифр после десятичной точки (0…18) определяется параметром Digits. Преобразование управляется глобальными переменными CurrencyString, CurrencyFormat, DecimalSeparator NegCurrFormat и ThousandSeparator, значения которых устанавливаются в диалоговом окне ‘Язык и стандарты’ панели управления Windows.

Пример
var
Sum: Extended;
SumStr: string;
begin
Sum:= 10255.2;
SumStr:= FloatToStrF( Sum, ffCurrency,18,2);
MessageDlg( SumStr, mtInformation, [mbOk], 0);
end;

NegCurrFormat — Переменная 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 должны выглядеть так:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Функции форматирования

Function FloatToStrF(Value: Extended; Format: TFloatFormat; Precision, Digits: Integer): String;

Преобразовывает число с плавающей запятой, в строковое представление.

Параметр Format определяет формат результирующей строки.

Параметр Precision определяет точность данного значения. Он должен быть равен 7 или меньше для значений типа Single, 15 или меньше для значений типа Double и 18 или меньше для значений типа Extended.

Значение параметра Digit зависит от выбранного формата.

Возможные значения параметра Format описаны ниже.

  • ffGeneral — общий формат числа. Значение преобразовывается в самую короткую возможную десятичную строку, использующую фиксированный или научный формат. Конечные нули удаляются, а десятичная точка появляется только в случае необходимости. Параметр Digit определяет минимальное число цифр в порядке числа (между 0 и 4).
  • ffExponent — научный формат. Значение преобразовывается в строку вида «-d. ddd . E + dddd». Общее количество цифр в результирующей строке (включая одну перед десятичной точкой) определяется параметром Precision. Параметр Digit определяет минимальное число цифр в порядке числа (между 0 и 4).
  • ffFixed — фиксированный формат. Значение преобразовывается в строку вида «-ddd. ddd . «. Число цифр после десятичной точки определяется параметром Digit и должно быть не больше 18. Если число цифр слева от десятичной точки больше, чем определено в параметре Precision, используется научный формат.
  • ffNumber — числовой формат. Значение преобразовывается в строку вида «-d, ddd, ddd.ddd . «. Формат ffNumber соответствует формату ffFixed, за исключением того, что возникающая в результате строка содержит разделитель тысяч.
  • ffCurrency — денежный формат. Значение преобразовывается в строку, которая представляет собой денежную величину. Преобразование управляется глобальными переменными CurrencyString, CurrencyFormat, NegCurrFormat, ThousandSeparator и DecimalSeparator, которые определяются соответствующими значениями раздела «Язык и стандарты» Панели управления Windows. Число цифр после десятичной точки определяется параметром Digits и должно быть не больше 18.

Если параметр Value принимает бесконечное значение (с плюсом или минусом), функция возвращает соответственно «INF» или «-INF».

Function StrToFloat(const S: String): Extended;

Преобразовывает данную строку в число с плавающей запятой. Строка должна состоять из необязательного знака (+ или -), последовательности цифр с необязательной десятичной точкой и необязательным «E» или «e», сопровождаемым целым числом со знаком.

Глобальная переменная DecimalSeparator определяет символ, который будет использоваться как десятичная точка. Разделитель тысяч и обозначения денежной единицы не допускаются. Если строка имеет неверный формат, возбуждается исключительная ситуация EConvertError.

Function IntToStr(Value: Integer): String;

Преобразовывает целое число в строку.

Function StrToInt(const S: String): Integer;

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

NegCurrFormat — Переменная 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.

Илон Маск рекомендует:  Работа с http протоколом

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

Есть ли способ, чтобы изменить валюту почти во всем мире, то есть, для всех данных Currency представлены в форме?

Даже с той же валютой, возможно , придется отображать значения в другом формате (сепараторов например), поэтому я рекомендую вам связать LOCALE вместо валюты только с вашими ценностями.
Вы можете использовать простой Integer для хранения LCID (Locale ID).
Смотрите список здесь: http://msdn.microsoft.com/en-us/library/0h88fahh.aspx

Тогда для отображения значений, использовать что-то вроде:

Я хотел бы использовать SysUtils.CurrToStr (Value: Валюта; Var FormatSettings: TFormatSettings): String;

Я бы программу настройки массив TFormatSettings, каждую позицию, сконфигурированный для отражения каждой валюты ваше приложение поддерживает. Вам необходимо установить следующие поля Настройки TFormat для каждой позиции массива: CurrencyString, CurrencyFormat, NegCurrFormat, ThousandSeparator, DecimalSeparator и CurrencyDecimals.

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

При форматировании строк с помощью функций Format, FormatBuf, StrFmt, StrLFmt, процедуры FmtStr, в качестве одного из параметров, в данных подпрограммах используется строка форматирования. Строка форматирования может содержать в себе два типа объектов — обычные символы и спецификаторы (команды форматирования). Обычные символы копируются один к одному в результирующую строку. Спецификаторы применяются для выборочного форматирования элементов из списка аргументов.

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

«%» [index «:»] [«-«] [width] [«.» prec] type

Спецификатор начинается с символа %. За ним следуют:

Необязательный параметр [index «:»], задающий индекс аргумента.
Индикатор выравнивания по левому краю [«-«] (необязательный параметр).
Необязательный параметр [width], задающий минимальную длину результирующей строки.
Необязательный параметр [«.» prec], задающий точность.
Символ преобразования типа, type.

Идентификатор type может иметь одно из значений представленных в таблице:

d Десятичный формат. Аргумент должен иметь целочисленное значение, которое будет преобразовано в строку символов десятичных цифр. Если строка форматирования содержит спецификатор точности prec, то результирующая строка должна содержать, как минимум, указанное в спецификаторе количество цифр. Если аргумент содержит меньшее количество цифр, то в результирующую строку перед значением числа будут добавлены нули.
u Десятичный беззнаковый формат. Форматируется аналогично параметру d, но знак числа не выводится.
e Научный формат. Аргумент должен представлять собой число с плавающей запятой. Значение будет преобразовано в строку формата «-d.ddd. E+ddd». Результирующая строка начинается со знака минус, если значение аргумента отрицательно. Десятичной точке всегда предшествует одна цифра. Общее количество цифр, включая стоящую перед десятичной точкой, задается спецификатором точности. Если спецификатор точности отсутствует, то используется значение по умолчанию — 15 цифр. После символа экспоненты всегда стоит знак плюс или минус и как минимум трехразрядное число.
f Фиксированный формат. Аргумент должен быть числом с фиксированной десятичной точкой. Значение аргумента будет преобразовано в строку формата «-ddd.ddd. «. Результирующая строка начинается со знака минус, если аргумент отрицателен. Количество десятичных знаков после разделителя определяется спецификатором точности prec. Если спецификатор точности отсутствует, то после десятичной точки выводятся заданные по умолчанию 2 десятичных знака.
g Общий формат. Аргумент должен быть числом с плавающей запятой. Значение аргумента преобразовывается в наиболее возможно короткую строку, используя фиксированный или научный формат. Количество значащих цифр в результирующей строке задается спецификатором точности prec. При отсутствии данного параметра выводится по умолчанию 15 знаков. Нули в конце строки не выводятся, Десятичный разделитель ставится только в случае необходимости. Фиксированный формат используется, если количество значащих цифр до десятичной точки меньше или равно значению указанному в спецификаторе точности, и если значение аргумента больше или равно 0.00001. В других случаях в результирующей строке используется научный формат.
n Числовой формат. Аргумент должен быть числом с плавающей запятой. Результирующая строка имеет вид «-d,ddd,ddd.ddd. «. Данный формат аналогичен фиксированному формату. Отличие состоит в том, что результирующая строка включает в себя разделители тысяч.
m Денежный формат. Аргумент должен быть числом с плавающей запятой. Значение аргумента преобразовывается в строку, содержащую символ, денежной единицы. Преобразование производится в соответствии со значениями глобальных переменных CurrencyString, CurrencyFormat, CurrencyDecimals, NegCurrFormat, ThousandSeparator, DecimalSeparator. Если строка формата содержит спецификатор точности prec, то значение глобальной переменной CurrencyDecimals игнорируется.
p Указатель. Аргумент должен быть указателем (тип Pointer). Значение аргумента преобразовывается в строку из 8-ми символов формата ХХХХYYYY, где ХХХХ — адрес сегмента, а YYYY — смещение в шестнадцатеричной форме.
s Строковый формат. Аргумент должен представлять собою символ, строку типа string или PChar. Значение аргумента вставляется на место спецификатора. Длина результирующей строки задается спецификатором точности prec. Если длина исходной строки превышает значение спецификатора точности, то она усекается.
x Шестнадцатеричный формат. Аргумент должен иметь целочисленное значение. Значение аргумента преобразовывается в строку шестнадцатеричных чисел. Спецификатором точности prec, задает минимальное количество символов результирующей строки. Если исходное значение содержит меньшее количество цифр, то в начало результирующей строки будут проставлены недостающие нули.

Все вышеуказанные символы могут быть записаны как в верхнем, так и в нижнем регистре.
Параметры index, width, prec могут быть заданы непосредственно числовым значением (например «%8u») или косвенно с помощью символа звездочки (например «%*.*f»). Звездочка означает, что в данной позиции будет использоваться текущее значение из массива данных (соответствующее значение должно представлять собой целочисленное значение), например вызов функции:

Результирующей строкой в обоих случаях будет ‘12345.68’

Параметр width задает минимальную длину результирующей строки. Если количество символов в получаемой строке меньше значения width, то строка дополняется необходимым количеством пробелов. По умолчанию пробелы добавляются в начало строки. Для того, чтобы пробелы добавлялись в конец строки необходимо в строку формата перед параметром width поставить символ «-«.
Параметр index определяет, какой элемент массива данных будет подвергаться форматированию. Первый элемент массива имеет индекс 0. После числового значения индекса должен стоять символ двоеточия «:». Если параметр index опускается, то форматируется элемент следующий за элементом который подвергался форматированию в прошлый раз (Первое форматирование соответственно производится для первого элемента массива данных). Например, вызов функции:

Format( ‘%3d, %d, %0:d, %2:-4d, %d’, [ 1, 2, 3, 4 ] );

будет возвращать следующую строку ‘ 1,2,1,3 ,4’

Переменные Delphi

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

Илон Маск рекомендует:  Создание get_module

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

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

Заметка. Компилятор языка Delphi, как и компилятор языка Pascal, не различает использование прописных и строчных букв в идентификаторах переменных, то есть используя имена PROGRAM, Program, program, можно ввести обозначение одной и той же переменной. Обычно программисты обозначают переменные Delphi таким образом, чтоб ее имя было более-менее логически связано с ее непосредственным назначением.

Примеры переменных Delphi

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

логично присвоение следующих имен: корням квадратного уравнения — x1 и х2, а свободным коэффициентам — соответственно a, b и c.

Пример 2. Если программа содержит переменные, которым назначено хранение числовых данных о сумме покупки и величине скидки, то эти переменные можно обозначить идентификаторами (именами) соответственно totalsum и skidka. Чтобы использовать переменные в программе, написанной на любых языках программирования, в том числе и Delphi, ее необходимо объявить в разделе переменных var.

Объявление переменных Delphi

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

откуда: Имя является именем назначаемой переменной; Тип подразумевает тип данных; для их хранения как раз и используется переменная.

Пример 3:

Здесь двум переменным m и n присвоен тип real, а переменной k тип integer. В тексте исходной программы программист, как правило, объявляет каждую переменную, помещая ее в отдельной строке. Если в коде исходной программы присутствуют несколько переменных, которым присвоен один и тот же тип, то их имена перечисляют в одной строке, разделяя запятыми, и лишь после последней переменной, используя символ «:», указывают тип переменных:

Delphi 2006. Справочное пособие: Язык Delphi, классы, функции Win32 и .NET. — Архангельский А.Я.

Приведенный пример использовал функции AddCurrencySymbol и AddNegCurrencySymbol, доступные только в приложениях .NET. Но и в таких приложениях, и в приложениях VCL Win32 можно обойтись и без этих функций:

S := CurrToStr(M) + FormatSettings.CurrencyString;

Поле ThousandSeparator указывает символ, разделяющий тысячи (точнее, каждые три цифры). Значение #0 соответствует отсутствию разделителя. По умолчанию — символ пробела. Поле DecimalSeparator определяет символ, разделяющий целую и дробную части числа. По умолчанию в русской локализации это символ запятой, но можно заменить его, например, символом точки:

Поля ThousandSeparator и DecimalSeparator, судя по документации, должны влиять на формат отображения любых действительных чисел. Но реально поле ThousandSeparator влияет только на отображение монетарных значений. В приведенных выше примерах можно, например, заменить операторы формирования строк следующими:

51 := AddCurrencySymbol(CurrToStr(М, FormatSettings),

52 := AddNegCurrencySymbol(CurrToStr(М, FormatSettings),

FormatSettings.CurrencyString, FormatSettings.NegCurrFormat); S := CurrToStr(М, FormatSettings) + FormatSettings.CurrencyString;

На результатах вызова использованной в этих примерах формы функции CurrToStr скажется заданное форматирование. THandIeStream — класс VCL

Остальные поля записи TFormatSettings относятся к форматированию дат и времени. Поля ShortDateFormat и LongDateFormat содержат строки, определяющие краткий и полный форматы отображения дат (см. подробнее в разд. «ShortDateFormat, LongDateFormat — переменные VCL»). Поле DateSeparator определяет символ разделителя, используемого в формате отображения дат ShortDateFormat и в ряде других форматов. По умолчанию в русской локализации это символ точки. Но вы можете программно задать другой символ разделителя (см. подробнее в разд. «DateSeparator — переменная VCL», в котором описана одноименная переменная DateSeparator).

Поля ShortMonthNames и LongMonthNames являются массивами, содержащими соответственно краткие (« янв ». « дек ») и полные (« Январь ». « Декабрь ») названия месяцев. Аналогично поля ShortDayNames и LongDayNames являются массивами, содержащими соответственно краткие («Be». «Сб») и полные («воскресенье», . «суббота») названия дней недели. Конечно, указанные значения соответствуют русской локализации (см. подробнее в разд. «LongDayNames, LongMonthNames, ShortDayNames, ShortMonthNames — переменные VCL»).

Поля ShortTimeFormat и LongTimeFormat содержат строки, определяющие краткий и полный форматы отображения времени (см. подробнее в разд. «LongTimeFormat, ShortTimeFormat — переменные VCL»). TimeSeparator определяет разделитель в форматах времени (см. разд. «TimeSeparator — переменная VCL»). По умолчанию в русской локализации это символ двоеточия.

Поля TimeAMString и TimePMString определяют при 12-часовом формате времени суффиксы соответственно для периодов времени от О до 12 часов и от 12 до 24 часов. В русских приложениях, как правило, 12-часовой формат не используется.

Поле TwoDigitYearCenturyWindow используется при переводе даты из строкового представления с двумя цифрами, обозначающими год, в численное представление. Оно позволяет восстановить полный год, соответствующий дате. См. подробнее в разд. «TwoDigitCenturyWindow — переменная VCL».

Поле ListSeparator не относится к датам, времени и числам. Это поле содержит символ, которым разделяются элементы в различных списках.

THandleStream — класс VCL

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

Библиотеки VCL Win32, VCL .NET

Модуль VCL Win32 Classes

Пространство имен VCL .NET Borland.Vcl.Classes

Иерархия в VCL Win32 TObject — TStream

Иерархия в VCL .NET System.Object — Borland.Vcl.Classes.TStream

Класс THandleStream описывает поток, обеспечивающий доступ к источнику данных, в частности, к файлу, с помощью дескриптора. Работа с дескрипторами файлов описана в гл. 6 в разд. 6.1.3. Класс THandleStream предоствляет альтернативную возможность работы с дескрипторами. 610

Г лава 9 > Некоторые базовые классы, типы, переменные

Экземпляр потока THandleStream создается вызовом его конструктора:

public constructor Create(AHandle: Stream);

Параметр AHandle — это дескриптор источника данных. Если источником является файл, то дескриптор может быть получен функцией FileOpen, описанной в разд. 6.1.3. При этом файл должен быть открыт в режиме, допускающем те операции, которые будут выполняться потоком. Для чтения файл должен быть открыт в режиме fmOpenRead или fmOpenReadWrite, а для записи — в режиме fmOpen Write или fmOpenReadWrite.

Например, следующий код создает в приложении VCL Win32 поток Т, связанный с файлом Test.txt, открытым для чтения и записи:

var FileHandle : Integer; T: THandleStream;

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

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

nim>Может это:
nim>DECIMALSEPARATOR?

Или WinAPI GetLocaleInfo

От: Аноним
Дата: 24.03.04 14:24
Оценка: -1

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

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

var
c: Char;
begin
c:= GetLocaleChar(GetThreadLocale, LOCALE_SDECIMAL, ‘.’);
***********

таким макаром у тебя ф-ция вернет разделитель, установленный в винде. а на старте программы хорошо устанавливать DecimalSeparator:= ‘.’;

От: nim
Дата: 24.03.04 14:25
Оценка:

«kavlad» сообщил/сообщила в новостях следующее: news:581308@news.rsdn.ru.
From: kavlad

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

>Или WinAPI GetLocaleInfo
Если это принципиально

От: Lion_ua
Дата: 24.03.04 15:14
Оценка:
От: Slicer [Mirkwood] https://ru.linkedin.com/in/maksim-gumerov-039a701b
Дата: 24.03.04 17:50
Оценка: +1

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

>>Или WinAPI GetLocaleInfo
nim>Если это принципиально

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

От: Sinclair http://corp.ingrammicro.com/Solutions/Cloud.aspx
Дата: 25.03.04 04:56
Оценка: +1

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

NN>Подскащите какой функцией можно узнать какой десятичный разделитель, запятая или точка, указан в региональных настройках и используется системой. Если можно с примерчиком.
Вот фрагмент из TFM:

Delphi предоставляет информацию о текущей локали в виде переменных, а не функций. Эти переменные инициализируются при старте приложения (т.е. если поменять региональные настройки в процессе работы, то приложение этого не увидит). В принципе, можно эти настройки менять, и это повлияет на поведение функций из VCL (типа IntToStr), но я не рекомендую — часть используемого в приложении кода может обращаться не в SysUtils, а напрямую к WinAPI.

От: NicNici
Дата: 25.03.04 06:33
Оценка:
От: Аноним
Дата: 25.03.04 09:56
Оценка: 18 (1)

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

NN>Спасибо всем за участие и ваши ответы.

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

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

От: Slicer [Mirkwood] https://ru.linkedin.com/in/maksim-gumerov-039a701b
Дата: 25.03.04 10:04
Оценка:

Здравствуйте, Аноним, Вы писали:
А>Теперь про грабельки: пойди и в локальных настройках удали этот символ.

Так-таки и удали? Regional and Language Options такого изврата не позволит. Выдает ошибку, советуя, раз мы такие извращенцы, использовать символ пробела. Но это все равно символ, а не пустое место. Правда, при таких настройках строки парсить несколько сложнее
Или это только с определенной версии Windows они такие осторожные стали?

От: Leonid Troyanovsky
Дата: 25.03.04 10:42
Оценка: 34 (2) +1

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

S>Delphi предоставляет информацию о текущей локали в виде переменных, а не функций. Эти переменные инициализируются при старте приложения (т.е. если поменять региональные настройки в процессе работы, то приложение этого не увидит). В принципе, можно эти

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