EveryOne I need some esay way to change from integer and string in delphi 7
var
Str:String;
Int:Integer;
// Here what i need to do
Str:='123';
Int:=Str.AsInteger
// or use this
Int:=123;
Str=Int.AsString;
asked Jan 20, 2014 at 8:23
samsam
291 gold badge1 silver badge11 bronze badges
3
The easiest way is to use these two methods:
IntVal := StrToInt(StrVal); // will throw EConvertError if not an integer
StrVal := IntToStr(IntVal); // will always work
You can also use the more fault-tolerant TryStrToInt (far better than catching EConvertError):
if not TryStrToInt(StrVal, IntVal) then
begin
// error handling
end;
If you want to resort to a default value instead of handling errors explictly you can use:
IntVal := StrToIntDef(StrVal, 42); // will return 42 if StrVal cannot be converted
answered Jan 20, 2014 at 8:31
jpfolleniusjpfollenius
16.4k10 gold badges90 silver badges156 bronze badges
0
If you’re using a recent version of Delphi, in addition to the previous answers, you can alternatively use a pseudo-OOP syntax as you wanted to originally — the naming convention is just ToXXX not AsXXX:
Int := Str.ToInteger
Str := Int.ToString;
The Integer helper also adds Parse and TryParse methods:
Int := Integer.Parse(Str);
if Integer.TryParse(Str, Int) then //...
answered Jan 20, 2014 at 13:19
Chris RollistonChris Rolliston
4,7781 gold badge15 silver badges20 bronze badges
7
You can use:
StrToInt(s)
and
IntToStr(i)
functions.
answered Jan 20, 2014 at 8:25
maricnmaricn
5536 silver badges20 bronze badges
1
type
TForm1 = class(TForm)
Button1: TButton;
Edit1: TEdit;
procedure Button1Click(Sender: TObject);
end;
Integer = class
FValue: System.Integer;
function ToString: string;
public
property Value: System.Integer read FValue write FValue;
end;
var
Form1: TForm1;
implementation
function Integer.ToString: string;
begin
Str(FValue, Result);
end;
procedure TForm1.Button1Click(Sender: TObject);
var
Int:integer;
begin
Int.Value:=45;
Edit1.Text:=Int.ToString;
end;
end
LU RD
34.3k5 gold badges89 silver badges293 bronze badges
answered Apr 1, 2017 at 5:28
samsam
291 gold badge1 silver badge11 bronze badges
2
Приведение типов в Delphi: Преобразование целых чисел в строку и обратно
Преобразование целых чисел в строку и обратно
Начнем с рассмотрения специальных функций для преобразования несовместимых типов. Самое частое, что может понадобиться при программировании, — преобразование строк в число и обратно. Допустим, нужно написать программу, в которой пользователь будет вводить число в компонент TEdit. Чтобы получить доступ к содержимому Editl, надо написать Editl.Text. Так мы получим текстовое представление числа. Чтобы его преобразовать, необходимо воспользоваться специальной функцией.
Для преобразования строки в число используется функция strToint. У нее только один параметр — строка, а на выходе она возвращает число,
var
ch:Integer; begin
ch:=StrToInt(Editl.Text); II Преобразовываю Edit1.Text в число end;
В этом примере мы присвоили переменной ch значение, содержащееся в Editl. Text, которое было преобразовано в число. Теперь можно производить математические действия с введенным числом.
Обратное преобразование (превращение числа в строку) можно произвести с помощью функции IntToStr.
var
ch:Integer; begin
ch:=StrToInt(Edit1.Text); // Преобразовываю Editl.Text в число ch:=ch+1;
Edit1.Text:=IntToStr(ch); // Преобразовываю ch в строку end;
Когда вы преобразовываете строку в число, то должны быть уверенным в том, что строка содержит число. Если в строке будет хоть один символ, не относящийся к цифре, то во время преобразования произойдет ошибка. Чтобы избавиться от ошибок, можно использовать исключительные ситуации, заключая преобразование между try и except. Есть еще один способ — использовать функцию strTointDef, у которой уже два параметра:
- строка, которую надо преобразовать;
- значение по умолчанию, которое будет возвращено, если произошла ошибка.
Итак, наш пример можно подкорректировать следующим образом:
var
ch:Integer; begin
ch:=StrToIntDef(Editl.Text, 0); // Преобразовываю Editl.Text в число end;
В этом примере, если произойдет ошибка во время преобразования, то функция не будет выдавать ошибок, а вернет значение 0.
СОВЕТ. Когда необходимо перевести в число строку, которая получается в результате ввода пользователем данных, то обязательно учитывайте вероятность ошибки. Дело в том, что пользователи могут случайно нажать до или после ввода числа пробел и не увидеть этого, а ваша программа в результате выполнит недопустимую операцию, и если вы не отрабатываете корректно возникающие исключительные ситуации, то выполнение программы может завершиться аварийно, что очень плохо. Да, ошибка возникла из-за неверного ввода пользователем, но виноватым будете вы.
Помоги проекту! Расскажи друзьям об этом сайте:
- 60
- 1
- 2
- 3
- 4
- 5
Аннотация: В этой лекции вы познакомитесь с функциями преобразования одних типов данных в другие, научитесь создавать сложные выражения путем подстановки значений, познакомитесь с глобальной переменной DecimalSeparator и напишете приложение с серьезной защитой от некорректного ввода пользователем числа.
Преобразования типов
В любом языке программирования то и дело приходится преобразовывать
один тип данных в другой. К примеру, нам требуется, чтобы пользователь
ввел денежную сумму. Для этого нужно использовать вещественное число с
учетом того, что могут быть копейки. Однако нет компонентов, которые
позволят сразу ввести вещественное число, приходится пользоваться теми
компонентами, которые позволяют ввести вещественное число в виде
строки:
Пользователь воспринимает это так, будто вводит сразу цифры, однако
мы то знаем, что это строка только символов, изображающая число. И
чтобы действительно превратить ее в число, приходится использовать
преобразования типов. Некоторыми функциями, которые служат этим целям,
мы уже пользовались, давайте упорядочим эти знания и изучим новые
функции.
IntToStr()
Наиболее часто используемая функция. Как вы уже знаете, она
принимает в качестве параметра целое число, и возвращает его в виде
строки. Хотелось бы отметить еще одну особенность: эта функция
предназначена для любого целого числа, не обязательно Integer. Если у
вас есть переменная Byte, Word, Cardinal или Int64, все это переменные
целого типа, и для любой из них годится функция IntToStr().
Примеры использования:
var b : Byte; w : Word; i : Integer; begin b := 5; w := 10; i := 20; Edit1.Text := IntToStr(b); Edit2.Text := IntToStr(w); ShowMessage(IntToStr(i)); end;
StrToInt()
Эта функция напротив, принимает в качестве параметра строку,
изображающую целое число, и возвращает его в виде целого числа. Все,
что было сказано о типах данных в функции IntToStr(), справедливо и
для этой функции. Примеры использования:
var
b : Byte;
w : Word;
i : Integer;
begin
b := StrToInt(Edit1.Text); //внимание! Если пользователь введет число
//больше 255, произойдет ошибка!
w := StrToInt('50000');
i := StrToInt(Edit2.Text);
end;
Как видите, действия этих функций очень похожи, только в последнем
случае приходится применять осторожность, чтобы не превысить диапазон
возможных значений. Если вы заранее не знаете, какое число введет
пользователь, лучше использовать Integer или Cardinal, если число без
знака. Экономия памяти иной раз может вызвать серьезные ошибки в
программе.
FloatToStr()
Эта функция принимает в качестве параметра вещественное число (то
есть, число с запятой), и возвращает его в виде строки. Примеры
применения почти аналогичны функции IntToStr(), однако есть одна
особенность – если после запятой у Вас есть только нули, то функция
вернет строку в виде целого числа:
s := FloatToStr(125,00); // результат: '125'
Эта функция также предназначена для всех типов вещественных чисел.
StrToFloat()
Эта функция принимает в качестве параметра строку в виде
вещественного или целого числа, и возвращает это вещественное число.
Пример:
f := StrToFloat('125'); //результат: 125,0
FormatFloat()
Эта функция по своему предназначению похожа на функцию FloatToStr(), однако она является гораздо более мощным инструментом.
Эта функция не только возвращает вещественное число в качестве строки,
но еще и позволяет задать желаемый формат этой строки. В прошлых
примерах мы говорили, что функция FloatToStr() вместо строки ‘125,00’
выведет ‘125’. А если нужно все-таки ‘125,00’? Такое сплошь и рядом
встречается, особенно в финансовой документации. Для этих целей и
создана функция FormatFloat.
Она имеет два параметра – строку формата и само число. Строка может
содержать следующие форматы:
| Строка, указываемая в формате | Примеры чисел | |||
|---|---|---|---|---|
| 1234 | -1234 | 0,5 | 0 | |
| 0 | 1234 | -1234 | 1 | 0 |
| 0.00 | 1234,00 | -1234,00 | 0,50 | 0,00 |
| #.## | 1234 | -1234 | 0,5 | 0 |
| #,0.00 | 1 234,00 | -1 234,00 | 0,50 | 0,00 |
Есть и другие варианты форматов, например, для представления числа
в экспонентной форме, но они, как правило, не используются.
Поясним строку форматов подробней.
В первом случае показаны варианты возвращаемых строк, если строка
форматов вообще не указана.
«Решетка» (#) работает также, как «ноль», с той разницей, что если
на этом месте не окажется цифры, то «решетка» ничего не выведет, а
«ноль» подставит в это место ноль.
Знак запятая здесь указывают для удобного отображения разрядности числа.
Например, миллион будет выглядеть как строка ‘1 000 000’. Заметим, что
на само число этот формат не оказывает никакого влияния, он нужен
только для того, чтобы выводить число в удобочитаемой форме в виде
строки.
Примеры использования:
var
f : Real;
begin
f := 1234567,00;
ShowMessage(FormatFloat('0,000.00' ,f)); //результат: "1 234 567,00"
ShowMessage(FormatFloat(f)); //результат: "1234567"
end;
Преобразование чисел с плавающей запятой
BCDToCurr (только в Delphi 5) — Конвертирует двоичный код десятичного значения (BCD) в значение типа Currency.
CompToDouble (только в Delphi 5) — Конвертирует значение типа Comp в значение типа Double.
CompToCurrency (только в Delphi 5) — Конвертирует значение типа Comp в значение типа Currency.
CurrencyToComp (только в Delphi 5) — Конвертирует значение типа Currency в значение типа Comp.
CurrToBCD (только в Delphi 5) — Конвертирует значение типа Currency в соответствующий двоичный код десятичного числа (BCD).
CurrToFMTBCD (только в Delphi 4) — Конвертирует значение типа Currency в соответствующий двоичный код десятичного числа (BCD).
CurrToStr — Конвертирует значение типа Currency в значение типа string.
CurrToStrF — Конвертирует значение типа Currency в строку, используя заданный формат.
DoubleToComp (только в Delphi 5) — Конвертирует значение типа Double в значение типа Comp.
FloatToDecimal — Преобразовывает число с плавающей запятой в десятичное представление, подходящее для дальнейшего форматирования.
FloatToStr — Конвертирует значение типа Extended в значение типа string.
FloatToStrF — Конвертирует значение типа Extended в строку, используя заданный формат.
FloatToText — Конвертирует значение с плавающей запятой в незавершенную символьную строку, используя заданный формат, помещает полученную строку в буфер и возвращает количество символов строки.
FloatToTextFmt — Конвертирует значение числа с плавающей запятой в незавершенную символьную строку, используя заданную маску, помещает полученную строку в буфер и возвращает количество символов строки.
FMTBCDToCurr (только в Delphi 4) — Конвертирует двоичный код десятичного значения (BCD) в значение типа Currency.
FormatCurr — Конвертирует значение типа Currency в строку, используя заданную маску.
FormatFloat — Конвертирует значение типа Extended в строку, используя заданную маску.
StrToCurr — Преобразовывает строковое представление числа с плавающей запятой в значение типа Currency.
StrToFloat — Преобразовывает строковое представление числа с плавающей запятой в значение типа Extended.
TextToFloat — Преобразовывает строковое представление числа в значение типа Currency или Extended.
Преобразование значений целочисленных типов
IntToHex — Возвращает шестнадцатеричное представление десятичного целого числа.
IntToStr — Возвращает строковое представление целого числа.
StrToInt — Преобразовывает строковое представление десятичного или шестнадцатеричного целого числа в значение типа Integer.
StrToInt64 — Преобразовывает строковое представление десятичного или шестнадцатеричного целого числа в значение типа Int64.
StrToInt64Def — Преобразовывает строковое представление десятичного или шестнадцатеричного целого числа в значение типа Int64. При ошибке возвращает значение по умолчанию.
StrToIntDef — Преобразовывает строковое представление десятичного или шестнадцатеричного целого числа в значение типа Integer. При ошибке возвращает значение по умолчанию.
Функции и процедуры для работы с типом Variant
VarArrayCreate — Создает массив Variant-значений.
VarArrayDimCount — Определяет количество измерений (размерностей) Variant-массива.
VarArrayFromStrings (только в Delphi 4) — Создает Variant-массив на базе объекта TStrings.
VarArrayHighBound — Возвращает верхнюю границу указанного измерения Variant-массива.
VarArrayLock — Блокирует Variant-массив.
VarArrayLowBound — Возвращает нижнюю границу диапазона указанного измерения Variant-массива.
VarArrayOf — Создает и заполняет одномерный массив значений типа Variant.
VarArrayRedim — Изменяет размеры Variant-массива.
VarArrayRef — Возвращает ссылку на массив значений типа Variant.
VarArrayUnlock — Разблокирует Variant-массив.
VarAsType — Приводит значение Variant-переменной к заданному типу.
VarCast — Приводит значение Variant-переменной к заданному типу.
VarClear — Очищает переменную типа Variant.
VarCopy — Копирует значение Variant-переменной в другую Variant-переменную.
VarFromDateTime — Преобразовывает значение типа TDateTime в значение типа Variant.
VarIsArray — Определяет, является ли Variant-переменная массивом.
VarIsEmpty — Определяет, задан ли тип Variant-переменной.
VarIsNull — Определяет, имеет ли Variant-переменная значение Null.
VarToDateTime — Преобразовывает значение даты и времени типа Variant в значение типа TDateTime.
VarToStr — Конвертирует значение типа Variant в значение типа string.
VarType — Определяет тип Variant-переменной.
VarTypeToDataType (только в Delphi 5) — Преобразовывает значение, определяющее тип Variant-переменной, в наиболее подходящее значение типа TFieldType.
Функции и процедуры для работы с датой и временем
Date — Возвращает текущую дату в формате TDateTime.
DateTimeToFileDate — Конвертирует значение даты и времени формата TDateTime в значение даты и времени формата DOS.
DateTimeToStr — Преобразовывает значение даты и времени формата TDateTime в его строковое представление.
DateTimeToString — Преобразовывает значение даты и времени формата TDateTime в строку, используя заданный формат.
DateTimeToSystemTime — Конвертирует значение даты и времени формата TDateTime Delphi в формат TSystemTime Win32 API.
DateTimeToTimeStamp — Преобразовывает значение даты и времени формата TDateTime в соответствующее значение TTimeStamp.
DateToStr — Преобразовывает значение даты формата TDateTime в ее строковое представление.
DayOfWeek — Возвращает порядковый номер дня недели указанной даты.
DecodeDate — Возвращает отдельно год месяц и день для значения типа TDateTime.
DecodeTime — Возвращает отдельно часы, минуты, секунды и миллисекунды для значения времени указанного в формате TDateTime.
EncodeDate — Преобразовывает отдельные значения года, месяца и дня в значение типа TDateTime.
EncodeTime — Преобразовывает значения часов, минут, секунд и миллисекунд в значение типа TDateTime.
FileDateToDateTime — Преобразовывает DOS переменную «дата-время» в формат TDateTime.
FormatDateTime — Преобразовывает значение даты и времени типа TDateTime в строку заданного формата.
IncMonth — Увеличивает или уменьшает дату на заданное количество месяцев.
IsLeapYear — Определяет, является ли указанный год високосным.
MsecsToTimeStamp — Преобразовывает значение времени в миллисекундах в значение типа TTimeStamp.
Now — Возвращает текущую дату и время в формате TDateTime.
ReplaceDate (только в Delphi 5) — Изменяет дату в значении даты и времени типа TDateTime.
ReplaceTime (только в Delphi 5) — Изменяет время в значении даты и времени типа TDateTime.
StrToDate — Преобразовывает строковое представление даты в значение типа TDateTime.
StrToDateTime — Преобразовывает строковое представление даты и времени в значение типа TDateTime.
StrToTime — Преобразовывает строковое представление времени в значение типа TDateTime.
SystemTimeToDateTime — Конвертирует значение времени формата Win32 API TSystemTime в значение Delphi-формата TDateTime.
Time — Возвращает текущее значение времени в формате TDateTime.
TimeStampToDateTime — Преобразовывает значение типа TTimeStamp в соответствующее значение типа TDateTime.
TimeStampToMSecs — Подсчитывает суммарное количество миллисекунд в значении типа TTimeStamp.
TimeToStr — Преобразовывает значение времени формата TDateTime в его строковое представление.
Процедуры для работы с множествами
Exclude — Удаляет элемент из множества.
Include — Добавляет элемент во множество.
Прочие процедуры и функции для работы с переменными
Assert — Проверяет истинность булева выражения.
Assigned — Определяет, имеет ли переменная значение nil.
FillChar — Заполняет переменную заданным количеством байт.
Hi — Возвращает старший байт значения аргумента.
High — Возвращает наибольшее допустимое значение в диапазоне значений аргумента.
Lo — Возвращает младший байт аргумента.
Low — Возвращает наименьшее допустимое значение в диапазоне значений аргумента.
Move — Копирует заданное количество байт из одной переменной в другую.
источник: Delphi по-русски.
web-master © Бутко А. В.
последние изменения: 01/11/2002
Основы Delphi: 4. Операции над целыми числами
Целочисленные типы данных играют ключевую роль в создании любой программы, которая будет выполняться микропроцессором. Основные регистры процессора — целочисленные, а большинство команд работают именно с этими регистрами. Поэтому очень важно эффективно использовать операции над целыми числами. Большинство компиляторов уже имеют средства, позволяющие генерировать оптимальный код, однако программист должен рационально использовать операции над целыми числами и не создавать лишних действий в программе.
32-битный микропроцессор оптимально работает с 32-битными значениями, поэтому в языке Delphi рекомендуется использовать типы integer и cardinal для операций с целыми числами. Однако, остальные целочисленные типы также могут быть использованы, если необходимо особым образом определить некую область памяти.
Целочисленные типы
Далее представлены все целочисленные типы языка Delphi. В таблице указано сколько памяти занимает значение того или иного типа:
| Тип | Описание | Размер памяти | Значения |
| byte | Беззнаковое целое | 1 байт | 0..255 |
| shortint | Знаковое целое | 1 байт | -128..127 |
| word | Беззнаковое целое | 2 байта | 0..65535 |
| smallint | Знаковое целое | 2 байта | -32768..32767 |
| cardinal longword |
Беззнаковое целое | 4 байта | 0..4294967295 или 0..232-1 |
| integer longint |
Знаковое целое | 4 байта | -2147483648..2147483647 или -231..231-1 |
| int64 | Знаковое целое | 8 байт | -9223372036854775808..9223372036854775807 или -263..263-1 |
| uint64 | Беззнаковое целое | 8 байт | 0..18446744073709551615 или 0..264-1 |
Для того, чтобы определить в программе, сколько памяти занимает тот или иной тип, можно использовать функцию SizeOf:
program TypeSize;
{$APPTYPE CONSOLE}
begin
WriteLn(‘byte: ‘,SizeOf(byte));
WriteLn(‘word: ‘,SizeOf(word));
WriteLn(‘cardinal: ‘,SizeOf(cardinal));
WriteLn(‘uint64: ‘,SizeOf(uint64));
ReadLn;
end.
byte: 1
word: 2
cardinal: 4
uint64: 8
Структура целочисленного значения
Для типа byte со структурой все понятно: занимает один байт, от 0 до 255, т.е. от 00000000 до 11111111 в двоичном виде. В структуре числа нет информации о знаке числа, поэтому тип и называется — беззнаковый.
Для знакового типа shortint необходимо сохранять информацию о знаке — для этого достаточно одного старшего (первого слева) бита. Если он равен 0, то число — положительное (или равное нулю) и его значения варьируются от 0 до 127, т.е. от 00000000 до 01111111. Если старший бит равен 1, то число — отрицательно, и оставшиеся 7 бит являются разностью между числом 128 и модулем искомого числа (так называемый дополнительный код числа). Например:
| -1 | 11111111 |
| -2 | 11111110 |
| -3 | 11111101 |
| -128 | 10000000 |
Остальные целочисленные типы требуют больше, чем 1 байт памяти. Для удобства байты значения в памяти записывают в обратном порядке. Например число 123456 типа integer, которое в двоичном и шестнадцатиричном виде записывается как
00000000000000011110001001000000
0001E240
в памяти будет представлено в виде
01000000 11100010 00000001 00000000
40 E2 01 00
Чтобы убедиться в том, что байты значения в памяти записываются в обратном порядке можно провести эксперимент. Возьмем у числа 789 (или 0000001100010101) типа word только первый байт, и он должен равняться 21 (или 00010101), а не 3 (или 00000011) при прямом порядке:
program ByteOrder;
{$APPTYPE CONSOLE}
var
A: word;
P: pointer;
begin
A := 789;
P := @A; // указатель на область памяти переменной A
WriteLn( A );
WriteLn( PByte(P)^ ); // выводим первый байт области памяти
// на который указывает P
ReadLn;
end.
789
21
Операции
Операции над целыми числами можно разделить на арифметические и побитовые. Арифметические операции представлены в следующей таблице:
| Знак | Операция | Пример | Результат |
| + | Сложение | 7 + 4 | 11 |
| — | Вычитание | 7 — 4 | 3 |
| * | Умножение | 7 * 4 | 28 |
| / | Деление | 7 / 4 | 1.75 (всегда вещественное) |
| div | Деление без остатка | 7 div 4 | 1 (всегда целое) |
| mod | Остаток от деления | 7 mod 4 | 3 |
Побитовые (bitwise) операции отличаются от арифметических тем, что взаимодействуют не сами числа, а соответствующие биты. Для каждой пары битов выполняется какая-либо логическая операция, и результат побитовой операции будет составляться из результатов логических операций для каждой пары бит.
| Знак | Операция | Пример | Результат |
| not | Отрицание | not 5 (¬ 00000101) | -6 (11111010) |
| and | Побитовое логическое «И» | 5 and 7 (00000101 ^ 00000111) | 5 (00000101) |
| or | Побитовое логическое «ИЛИ» | 5 or 7 (00000101 v 00000111) | 7 (00000111) |
| xor | Побитовое логическое «исключающее ИЛИ» | 5 xor 7 (00000101 xor 00000111) | 2 (00000010) |
| shl | Сдвиг битов влево | 22 shl 2 (00010110) | 88 (01011000) |
| shr | Сдвиг битов вправо | 22 shr 2 (00010110) | 5 (00000101) |
Приведение типов
Значения одного целочисленного типа приводятся к другому целочисленному типу без каких либо проблем. Следует учесть, что если новый тип занимает в памяти меньше байт, чем старый тип, то лишние байты просто отсекаются. Это также удобно, если необходимо получить первые несколько байт целочисленного значение (например, первый байт значения типа word или первые два байта значения типа cardinal). Однако, если тип значения знаковый, а само значение отрицательное, то приведение к типу, занимающему меньше памяти, может привести к положительному результату. Например, приводя значение -1000 (11111100 00011000) типа smallint к типу shortint, в результате получим 24 (00011000).
Значение результата какой-либо целочисленной операции всегда имеет тип, который занимает в памяти максимум из типов операндов. Например, integer + word = integer, int64 — byte = int64. Это может создать проблемы при операции умножения, когда результат необходимо получить с типом int64. В конструкции
var
a, b: integer;
c: int64;
…
c := a * b;
выражение (a * b) имеет тип integer, а не int64, и значение может переполниться. В этом случае следует привести один из операндов к типу int64. Явное приведение к какому-либо типу описывается следующим образом:
<тип> ( <выражение> )
В таком случае, текст программы выглядит так:
var
a, b: integer;
c: int64;
…
c := int64(a) * b;