LongWord — Тип Delphi


Целочисленные типы данных

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

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

Например, тип данных Integer в Delphi имеет диапазон -2147483648…2147483647, в то время как в Turbo Pascal тип данных Integer представляет числа в диапазоне -35768…32767. В Free Pascal диапазон значений типа Integer определяется выбранным режимом.

Так как Lazarus использует компилятор Free Pascal, то всё сказанное о типах данных по отношению к Free Pascal справедливо и для Lazarus.

Итак, целочисленные типы данных Free Pascal перечислены в таблице 13.1.

Таблица 13.1. Целочисленные типы данных Free Pascal (Lazarus).

Тип Размер, байт Диапазон значений
Byte 1 0…255
Shortint 1 -128…127
Smallint 2 -35768…32767
Word 2 0…65535
Integer 2 или 4 Зависит от режима компиляции
Cardinal 4 0…4294967295
Longint 4 -2147483648…2147483647
Longword 4 0. 4294967295
Int64 8 -9223372036854775808. 9223372036854775807
QWord 8 0. 18446744073709551615

ПРИМЕЧАНИЕ
В Free Pascal типы Int64 и QWord не являются порядковыми! Это означает, что вы не можете использовать их, например, для индексных переменных в циклах. Однако я привёл их здесь, чтобы отдельно не описывать в будущем и собрать в одном месте все целочисленные типы Free Pascal. Если какие-то слова вам не понятны — не пугайтесь. В своё время я обо всём расскажу подробнее.

А теперь несколько пояснений к таблице.

В колонке ТИП приведены идентификаторы типов данных (ключевые слова, которые указывают компилятору, к какому типу относятся те или иные данные). Как использовать эти идентификаторы, вы узнаете в следующих уроках.

В колонке РАЗМЕР указан размер, который занимает тип данных в памяти компьютера. Например, целое положительное число можно представить разными типами: Byte, Word, Cardinal и др. Однако число типа Cardinal будет занимать в памяти 4 байта, в то время как число типа Byte – всего лишь 1 байт. Поэтому, если вы точно знаете, что число, с которым вы работаете, никогда не примет значение больше 255, то лучше определять его как тип Byte, так как это позволит сэкономить место в памяти компьютера. Хотя здесь не всё так однозначно (нюансы распределения памяти и других ресурсов компьютера выходят за рамки данного курса).

В колонке ДИАПАЗОН указан диапазон значений, которым оперирует тип данных. Например, число типа Byte может принимать значения от 0 до 255.

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

Стандартная функция Low определяет минимальное значение типа данных. Фунцкия High определяет максимальное значение. С функциями WriteLn и ReadLn вы уже немного знакомы. Более подробно о подпрограммах (процедурах и функциях) мы будем говорить в соответствующем разделе курса.

Напоследок скажу, как записываются целочисленные данные в программе. Да также как и везде — просто пишите число, без кавычек и каких-либо дополнительных символов. Например, так

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

Free Pascal поддерживает четыре формата записи целого числа:

  1. Десятичная запись. Просто число, например 10.
  2. Шестнадцатеричная запись. Число с префиксом $. Например, шестнадцатеричное число $10 равно десятичному 16.
  3. Восьмеричная запись. Число с префиксом &. Например, восьмеричное число &10 равно десятичному 8.
  4. Двоичная запись. Число с префиксом %. Например, двоичное число %10 равно десятичному 2.

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

Создайте программу, которая выводит на экран диапазоны значений целых чисел (листинг 13.1). Откомпилируйте программу и запустите её. Убедитесь, что эти значения соответствуют указанным в таблице 13.1.

В исходном коде программы найдите строку, которая задаёт режим компиляции:

В этой строке вместо слова objfpc напишите слово tp. То есть итоговая строка должна выглядеть так:

Запустите программу. Посмотрите диапазон значений типа Integer. Сделайте выводы.

Учитесь думать как программист, то есть логически. Никто вам до пенсии не будет всё разжёвывать, как это делаю сейчас я. Надо привыкать думать самостоятельно. Иначе вы скатитесь к “обезьяньему принципу обучения”, и тогда ваши шансы стать классным программистом приблизятся к нулю. Чтобы помочь вам не скатиться на уровень “зубрёжки”, я буду периодически оставлять пробелы в вашем обучении, чтобы вы постарались сами додуматься до каких-то вещей.

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

Longword/Dword/Cardinal

08.08.2013, 19:34

String to longword
Помощь. ‘4a’ в $0000004a ‘ff’ в $000000ff и т.д.

Cardinal Integer
Мне нужно позицию трэкбара поменять на Timer1.Interval / 60000 Но есть проблема: у таймера интервал.

Деление cardinal или int64
var Global_EdiniaIzmerenia:cardinal; . Global_EdiniaIzmerenia:=Global_EdiniaIzmerenia/100;.

Когда использовать integer, а когда — cardinal?
У меня немного общий вопрос. В книгах и самоучителях, которые мне встречались, часто в начале учат.

тип DWord
Подскажите, пожалуйста, что за тип такой Dword? в delphi XE не определяется, — каким его можно.

08.08.2013, 19:34

Чтение типа DWord
Вот таким образом я читаю символьный тип из реестра.var FIniFile: TRegIniFile; . FIniFile :=.

Преобразование String в DWORD
Я считываю значение с файла и пытаюсь его преобразовать в DWORD. Но выдает ошибку, так как значение.

Вопрос по реестру и DWORD
У меня возникла следующая проблема Я пытаюсь записать параметр типа DWORD в реестр, а он у меня.

Типы данных Delphi

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

  • целые и дробные числа,
  • символы,
  • строки символов,
  • логические величины.

Целый тип Delphi

Библиотека языка Delphi включает в себя 7 целых типов данных: Shortint, Smallint, Longint, Int64, Byte, Word, Longword, характеристики которых приведены в таблице ниже.

Вещественный тип Delphi

Кроме того, в поддержку языка Delphi входят 6 различных вещественных типов (Real68, Single, Double, Extended, Comp, Currency), которые отличаются друг от друга, прежде всего, по диапазону допустимых значений, по количеству значащих цифр, по количеству байт, которые необходимы для хранения некоторых данных в памяти ПК (характеристики вещественных типов приведены ниже). Также в состав библиотеки языка Delphi входит и наиболее универсальный вещественный тип — тип Real, эквивалентный Double.

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

Символьный тип Delphi

Кроме числовых типов, язык Delphi располагает двумя символьными типами:

Тип Ansichar — символы c кодировкой ANSI, им ставятся в соответствие числа от 0 до 255;

Тип Widechar — символы с кодировкой Unicode, им ставятся в соответствие числа от 0 до 65 535.

Строковый тип Delphi

Строковый тип в Delphi обозначается идентификатором string. В языке Delphi представлены три строковых типа:

Тип Shortstring — присущ статически размещаемым в памяти ПК строкам, длина которых изменяется в диапазоне от 0 до 255 символов;

Тип Longstring — этим типом обладают динамически размещаемые в памяти ПК строки с длиной, ограниченной лишь объемом свободной памяти;

Тип WideString — тип данных, использующийся для того, чтобы держать необходимую последовательность Интернациональный символов, подобно целым предложениям. Всякий символ строки, имеющей тип WideString, представляет собой Unicode-символ. В отличие от типа Shortstring, тип WideString является указателем, который ссылается на переменные.

Логический тип Delphi

Логический тип соответствует переменным, которые могут принять лишь одно из двух значений: true, false. В языке Delphi логические величины обладают типом Boolean. Вам были представлены основные типы данных Delphi. Движемся дальше.

Разница между LongInt и Integer, LongWord и Cardinal

В Delphi, в чем разница между LongInt и Integer, LongWord и Cardinal?

и иногда я нахожу использование DWORD, что это?

Они совместимы во всех версиях Delphi? к какой я должен придерживаться?

5 ответов

Вкратце: Longint и Longword — это целые числа фиксированного размера, первые со знаком, последние без знака, и оба обычно имеют размер 32 бита. Их размер зависит от платформы в XE8, но фиксированный размер (32 бита) в XE7 и более ранних версиях.

Integer и Cardinal не имеют фиксированного размера. Они являются так называемыми «универсальными» целыми числами (не путайте это с дженериками, которые представляют собой другую пару ботинок), т.е. их предпочтительно использовать, когда требуется целочисленный тип, независимо от размера. В зависимости от версии и платформы размер Integer и Cardinal может различаться. В настоящее время они имеют тот же размер и тип, что и Longint и Longword.

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

Обратите внимание, что в текущих версиях есть псевдонимы для типов, таких как Byte или Smallint. Это Int8, UInt8, Int16, UInt16 и т. Д. До UInt64. ISTM, что эти имена легче запомнить, чем, например, «Smallint» (16-битная подпись) или «Shortint» (8-битная подпись).

Поэтому используйте Integer и Cardinal, когда это возможно, поскольку это, вероятно, идеальные типы для платформы и версии. Используйте типы фиксированного размера, такие как Byte, Smallint, Longint или UInt64, просто чтобы назвать несколько, когда требуется точная двоичная совместимость с другими данными.

Обновить

Так как произошла некоторая путаница (см. Ссылку вверху), и в настоящее время Longint и Longword больше не считаются независимыми от платформы фиксированного размера, но, как ни странно, Integer и Cardinal считаются фиксированным размером, я все больше склоняюсь к использованию (U) версии IntXX, такие как UInt16 или Int32. Единственным исключением является мое использование байта, которое я не могу себе представить, когда меняю его размер (1).

И, конечно, я буду использовать Integer и Cardinal для всего, что требует целочисленного типа, для которого размер не так важен, например, для счетчиков циклов и т. Д.

LongWord — Тип Delphi

With the exception of floating point value types, all base types are ordinal types. Ordinal types have the following characteristics:

  1. Ordinal types are countable and ordered, i.e. it is, in principle, possible to start counting them one by one, in a specified order. This property allows the operation of functions as Inc , Ord , Dec on ordinal types to be defined.
  2. Ordinal values have a smallest possible value. Trying to apply the Pred function on the smallest possible value will generate a range check error if range checking is enabled.
  3. Ordinal values have a largest possible value. Trying to apply the Succ function on the largest possible value will generate a range check error if range checking is enabled.

Remark: Int64 and QWord are cons >

Integers

A list of pre-defined integer types is presented in table (3.1 ).

Name
Integer
Shortint
SmallInt
Longint
Longword
Int64
Byte
Word
Cardinal
QWord
Boolean
ByteBool
WordBool
LongBool
QWordBool
Char

The integer types, and their ranges and sizes, that are predefined in Free Pascal are listed in table (3.2 ). Please note that the qword and int64 types are not true ordinals, so some Pascal constructs will not work with these two integer types.

Type Range Size in bytes
Byte 0 .. 255 1
Shortint -128 .. 127 1
Smallint -32768 .. 32767 2
Word 0 .. 65535 2
Integer either smallint or longint size 2 or 4
Cardinal longword 4
Longint -2147483648 .. 2147483647 4
Longword 0 .. 4294967295 4
Int64 -9223372036854775808 .. 9223372036854775807 8
QWord 0 .. 18446744073709551615 8

The integer type maps to the smallint type in the default Free Pascal mode. It maps to either a longint in either Delphi or ObjFPC mode. The cardinal type is currently always mapped to the longword type.

Remark: All decimal constants which do no fit within the -2147483648..2147483647 range are silently and automatically parsed as 64-bit integer constants as of version 1.9.0. Earlier versions would convert it to a real-typed constant.

Remark: In newer Delphi versions, the longint type is platform and CPU dependent. This is not so in FPC, where longint is 32-bit on all platforms.

As a pascal compiler, Free Pascal does automatic type conversion and upgrading in expressions where different kinds of integer types are used:

  1. Every platform has a ”native” integer size, depending on whether the platform is 8-bit, 16-bit, 32-bit or 64-bit. e.g. On AVR this is 8-bit.
  2. Every integer smaller than the ”native” size is promoted to a signed version of the ”native” size. Integers equal to the ”native” size keep their signedness.
  3. The result of binary arithmetic operators (+, -, *, etc.) is determined in the following way:
    1. If at least one of the operands is larger than the native integer size, the result is chosen to be the smallest type that encompasses the ranges of the types of both operands. This means that mixing an unsigned with a smaller or equal in size signed will produce a signed type that is larger than both of them.
    2. If both operands have the same signedness, the result is the same type as them. The only exception is subtracting (-): in the case of unsigned-unsigned subtracting produces a signed result in FPC (as in Delphi, but not in TP7).
    3. Mixing signed and unsigned operands of the ”native” int size produces a larger signed result. This means that mixing longint and longword on 32-bit platforms will produce an int64. Similarly, mixing byte and shortint on 8-bit platforms (AVR) will produce a smallint.
Илон Маск рекомендует:  Атрибут formenctype в HTML
Boolean types

Free Pascal supports the Boolean type, with its two pre-defined possible values True and False . These are the only two values that can be assigned to a Boolean type. Of course, any expression that resolves to a boolean value, can also be assigned to a boolean type.


Name Size Ord(True)
Boolean 1 1
Boolean8 1 1
Boolean16 3 1
Boolean32 4 1
Boolean64 8 1
ByteBool 1 Any nonzero value
WordBool 2 Any nonzero value
LongBool 4 Any nonzero value
QWordBool 8 Any nonzero value

In addition to the simple Boolean type, the additional Boolean8 , Boolean16 , Boolean32 and Boolean64 types exist. There are in fact integer types, which are assignment-compatible with the simple boolean type. As an integer, the values for True and False are 1 and 0. This can be used to interfac with C code that defines a boolean of this size with values 0 and 1.

To make interfacing with C even easier, Free Pascal also supports the ByteBool , WordBool , LongBool and QWordBool types. These are of type Byte , Word , Longint or Int64 , but are again assignment compatible with a Boolean . The only difference with the Boolean8/16/32/64 types is in what values are cons >False is equivalent to 0 (zero) and any nonzero value is cons >True when converting to a boolean value. A boolean value of True is converted to Not(0) in case it is assigned to a variable of type ByteBool , WordBool , LongBool or QWordBool .

Assuming B to be of type Boolean , the following are val > B := True;
B := False;
B := 1<>2;

Boolean expressions are also used in conditions.

Remark: In Free Pascal, boolean expressions are by default always evaluated in such a way that when the result is known, the rest of the expression will no longer be evaluated: this is called short-cut boolean evaluation.

In the following example, the function Func will never be called, which may have strange s > .
B := False;
A := B and Func;

Here Func is a function which returns a Boolean type.

This behaviour is controllable by the < $B >compiler directive.

Enumeration types

Enumeration types are supported in Free Pascal. On top of the Turbo Pascal implementation, Free Pascal allows also a C-style extension of the enumeration type, where a value is assigned to a particular element of the enumeration list.

_________________________________________________________________________________________________________
Enumerated types

(see chapter 12 , page 534 for how to use expressions) When using assigned enumerated types, the assigned elements must be in ascending numerical order in the list, or the compiler will complain. The expressions used in assigned enumerated elements must be known at compile time. So the following is a correct enumerated type declaration:

A C-style enumeration type looks as follows:

As a result, the ordinal number of forty is 40 , and not 3 , as it would be when the ’:= 40’ wasn’t present. The ordinal value of fortyone is then 41, and not 4 , as it would be when the assignment wasn’t present. After an assignment in an enumerated definition the compiler adds 1 to the assigned value to assign to the next enumerated value.

When specifying such an enumeration type, it is important to keep in mind that the enumerated elements should be kept in ascending order. The following will produce a compiler error:

It is necessary to keep forty and thirty in the correct order. When using enumeration types it is important to keep the following points in mind:

  1. The Pred and Succ functions cannot be used on this kind of enumeration types. Trying to do this anyhow will result in a compiler error.
  2. Enumeration types are stored using a default, independent of the actual number of values: the compiler does not try to optimize for space. This behaviour can be changed with the < $PACKENUM n >compiler directive, which tells the compiler the minimal number of bytes to be used for enumeration types. For instance

will, when run, print the following:

_________________________________________________________________________________________________________
Subrange types

Some of the predefined integer types are defined as subrange types:

Subrange types of enumeration types can also be defined:

Разница между LongInt и Integer, LongWord и Кардинал

В Delphi, в чем разница между LongInt и Integer, LongWord и кардинал?

и иногда я нахожу использование DWORD, что это?

Соответствуют ли они во всех версиях Delphi? который один я должен придерживаться?

Короче говоря: Longint и LongWord закрепляются целые размера, бывший подписан, последний без знака, и как правило , 32 бита в размере. Их размер зависит от платформы в X Е8, но фиксированный размер (32 бита) в XE7 и более ранние версии.

Integer и Cardinal не фиксированный размер. Это так называемые «общие» целые числа (не путать с обобщениями, что другая пара обуви), т.е. предпочтительно следует использовать, когда требуется целочисленный тип, независимо от размера. В зависимости от версии и платформы, размер Integer и Cardinal может отличаться. В настоящее время они имеют одинаковый размер и тип, как Longint и LongWord.

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

Обратите внимание, что текущие версии имеют псевдонимы для типов, таких как байты или SMALLINT. Они INT8, Uint8, Int16, UInt16, и т.д . до uint64. ISTM, что эти имена легче запомнить, чем, например, «SMALLINT» (16 бит), подписанного или «SHORTINT» (8 бит), подписанного.

Поэтому использовать Integer и Cardinal всякий раз, когда это возможно, так как это, вероятно, идеальные типы для платформы и версии. Используйте типы фиксированного размера, как Byte, SMALLINT, Longint или uint64, просто назвать несколько, когда требуется точное бинарное Совместимость с другими данными.

  • Delphi Integer является C ++ Базовой платформы int .
  • Delphi LongInt является C ++ Базовой платформы long int .
  • Delphi Cardinal является C ++ Базовой платформы unsigned int .
  • Delphi LongWord является C ++ Базовой платформы unsigned long int .

Все четыре из этих типов зависят от платформы.

На всех поддерживаемых платформах в момент написания, Integer и Cardinal 32 битные типы. Эти типы зависят от платформы, так бывает , что на всех поддерживаемых платформах типа имеют одинаковый размер.

На 64 — битных платформах * NIX, LongInt и LongWord 64 битных типов. На всех других поддерживаемых платформах, на момент написания данного типа являются 32 — битные типы.

Ключевым моментом является то, что эти типы все зависят от платформы.

DWORD тип псевдоним, используемый в Windows API. Используйте его только тогда, когда с помощью этого API.

Если вы используете Integer или LongInt ? Это зависит от вашего использования. Как правило, для использования в зависимости от того , тип — взаимодействия соответствует код C ++. В противном случае, для большинства применений Integer целесообразно. Конечно, это общий ответ на общий вопрос.

LongWord — Тип Delphi

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

Возник вопрос — есть четыре переменные типа byte ,например a, b ,c ,d
Есть процедура, для которой входным параметром является четырехбайтовый блок — переменная типа longword.
Собственно вопрос. Как последовательно записать эти 4 байта в переменную лонгворд?

D e l p h i n , вообще-то нужно в обратном порядке — первым идет младший байт.

Еще вариант:
d : longword;
l : array[0..3]of byte absolute d;
begin
l[0] := a;
l[1] := b;
l[2] := c;
l[3] := d;

Не надо извиняться, пока кто-то не упрекнул.
Это так, отвлеченно от сути.

Теперь по сути. А что это за «четыре переменные типа byte»? И каким образом они связаны с некоей процедурой, требующей в качестве параметра LongWord? Вот что главное! А как 4-ре байта перевести в 4-х байтную переменную — это уже вторичный вопрос.

Благодарю, господа. Способы помогли. Но глобальной проблемы это не решило. Мб и в ней поможете.
Глобальная проблема следующая — имеются процедуры шифрования\расшифрования блока данных алгоритмом Серпент.
Меня смутили входные данные, представленные константой. И назначения в начале через указатели.
Я подумал, что можно сделать входными данными 4 переменные longword по 4 байта в каждом. все сделал и все организовал, но алгоритм работает неверно.. После шифрования размер файла остается таким же, да.. Но расшифрование не дает результата, а просто усложняет еще сильнее.
Процедуры верные 100% — из библиотеки DCPcrypt. Но просто юзать библиотеку не вариант — мне надо именно разобраться в ней.
Видимо мой вариант с заменой входных данных не вышел(( Помогите пожалуйста разобраться, что является входными данными для этой процедуры!

Difference between LongWord and Cardinal in Delphi XE?

This code doesn’t compile in XE :

[DCC Error]: E2026 Constant expression expected

Assignable typed constants is ON.

If I cast all the array values to LongWord in the first sample the code compiles. But I cannot get what’s the difference between LongWord and Cardinal?

3 Answers 3

I’m going to be bold, and state *there is no difference*. You arrived at the wrong conclusion somehow, and provided us with not enough information to help you out. I’m convinced you didn’t paste a 1:1 copy of your code here, and you left out something relevant.

Could be an evil workmate who pasted a little inivisble unicode character before the opening parenthesis, and defined that same character as a function elsewhere. It could also be something a little more obvious.

Can you reproduce the issue in a clean project? Because I’m pretty sure you can’t. If you can, post back. If you can’t, post more context. By all means, prove me wrong.

Язык программирования Delphi

данные графика программирование язык delphi

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

Каждая инструкция состоит из идентификаторов. Идентификатор может обозначать:

  • — Инструкцию языка (:=, if, while, for);
  • — переменную;
  • — константу (целое или дробное число);
  • — арифметическую (+, -,*,/) или логическую (and, or, not) операцию;
  • — подпрограмму (процедуру или функцию);
  • — отмечать начало (procedure, function) или конец (end) подпрограммы ИЛИ блока (begin, end).

Типы данных

Программа может оперировать данными различных типов: целыми и дробными числами, символами, строками символов, логическими величинами.

Язык Delphi поддерживает семь целых типов данных: shortint, smailint, Longint, Int64, Byte, word и Longword, описание которых приведено в табл. 1.1.

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

-2 147 483 648 — 2 147 483 647

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

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

0 — 4 294 967 295

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

Object Pascal поддерживает и наиболее универсальный целый тип — Integer, который Эквивалентен Longint.

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

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

2.9 x 10-39-1.7×1038

1.5 x 10-45-3.4х 1038

5.0 x10-324 -1.7×10308

3.6 x10-4951 -1.1 х104932

-922 337 203 685 477.5808 —922 337 203 685 477.5807

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

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

  • — тип Ansichar — это символы в кодировке ANSI, которым соответствуют числа в диапазоне от 0 до 255;
  • — тип widechar — это символы в кодировке Unicode, им соответствуют числа от 0 до 65 535.

Object Pascal поддерживает и наиболее универсальный символьный тип — Char, который эквивалентен Ansichar.

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

  • — WideString:
  • — тип shortstring представляет собой статически размещаемые в памяти компьютера строки длиной от 0 до 255 символов;
  • — тип Longstring представляет собой динамически размещаемые в памяти строки, длина которых ограничена только объемом свободной памяти;
  • — тип WideString представляет собой динамически размещаемые в памяти строки, длина которых ограничена только объемом свободной памяти. Каждый символ строки типа WideString является Unicode-символом.

В языке Delphi для обозначения строкового типа допускается использование идентификатора string. Тип string эквивалентен типу shortstring.

В языке Delphi для обозначения строкового типа допускается использование идентификатора string. Тип string эквивалентен типу shortstring.

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

Delphi LongWord is not always a 32 bit unsigned integer

Did you know that LongWord in Delphi is not (any longer) always a 32 bit unsigned integer?

I wasn’t aware of this until I asked about what others use for that data type in the Delphi Developers Google+ community.

I turned out that the majority of the participants use Cardinal, followed by Uint32.

Only less than 10% use LongWord.

Stefan Glienke was the first to point out that LongWord is not always 32 bits, even though the 64-bit Windows Data Types Compared to 32-bit Windows Data Types entry in the DokWiki seems to suggest it. But it only covers Data types for Windows.

There is a better overview table on the Simple Types reference page. Even though I find it rather odd that they say that Integer and Int64 are aliases for NativeInt (I wouldn’t have had that “alias” column in the Platform Dependent Integer Types table at all.)

So, where does that leave me? I guess it’s best to switch to Int / UInt + bitness for those types where it is important how many bits an integer has (such as in records that define data written to a file). For the other cases it might be better to use NativeInt or NativeUInt, which translates to Int32 / UInt32 on 32 bit platforms and Int64 and UInt64 on 64 bit platforms. Unless of course they don’t.

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