SmallInt — Тип Delphi


Целые типы

Список предопределенных целочисленных типов представлен в таблице (3.1).

Таблица 3.1: Предопределенные целочисленные типы

Целочисленные типы, и их диапазоны и размеры, предопределены во Free Pascal , и перечислены в таблице (3.2). Пожалуйста, отметьте, что типы QWord и Int64 не истинно перечисляемые, таким образом, некоторые конструкции языка Pascal не будут работать с этими двумя целочисленными типами.

Таблица 3.2: Предопределенные целочисленные типы

Размер в байтах

или SmallInt или LongInt

По умолчанию во Free Pascal тип Integer соответствует типу SmallInt . И типу LongInt в любом из двух режимов Delphi или ObjFPC . Тип Cardinal сейчас всегда соответствует типу LongWord .

Все десятичные константы, которые не входят в диапазон -2147483648 .. 2147483647 начиная с версии 1.9.0 , автоматически обрабатываются как 64 -разрядные целые константы. Более ранние версии будут конвертировать их в вещественные типизированные константы.

Free Pascal делает автоматическое преобразование типов в выражениях, где используются различные виды целочисленных типов:

1. Каждая платформа имеет родной размер целого числа, в зависимости от того, платформа 8 -бит, 16 -бит, 32 -бит или 64 -бит. например, на AVR это 8 -разрядная платформа.

2. Каждое целое число меньшее, родного размера повышается до базовой версии родного размера. Целые равные родному размеру сохраняют их разрядность.

3. Результат двоичных арифметических операций (+, –, * и т.д.) , определяется следующим образом:

a. Если по крайней мере один из операндов больше, чем нативный (родной) размер целого, то результатом выбирается наименьший тип, который охватывает диапазон типов обоих операндов. Это означает, что смешивание типа без знака с меньшим или равным по размеру знакового типа, даст тип, который больше, чем оба из них.

b. Если оба операнда имеют один и тот же тип (размер), то результатом будет такой-же тип. Единственным исключением является вычитание (–) : если один из типов без знаковой, операция вычитания даёт знаковый тип FPC (как и в Delphi , но не в TP7 ) .

c. Смешивние знаковых и беззнаковых типов родного целого типа — даёт тип, больший по размеру, и со знаком. Это означает, что при смешивании типов LongInt и LongWord на 32 -разрядных платформах будет производить Int64 . Аналогично, при смешивании типа Byte и ShortInt на 8 -разрядных платформах ( AVR ) , результатом будет тип SmallInt .

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

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

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

Например, тип данных 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. Сделайте выводы.

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

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

SmallInt — Тип Delphi

Основы 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..2 32 -1
integer
longint
Знаковое целое 4 байта -2147483648..2147483647
или -2 31 ..2 31 -1
int64 Знаковое целое 8 байт -9223372036854775808..9223372036854775807
или -2 63 ..2 63 -1
uint64 Беззнаковое целое 8 байт 0..18446744073709551615
или 0..2 64 -1

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

begin
WriteLn( ‘byte: ‘ ,SizeOf(byte));
WriteLn( ‘word: ‘ ,SizeOf(word));
WriteLn( ‘cardinal: ‘ ,SizeOf(cardinal));
WriteLn( ‘uint64: ‘ ,SizeOf(uint64));

Структура целочисленного значения

Для типа byte со структурой все понятно: занимает один байт, от 0 до 255, т.е. от 00000000 до 11111111 в двоичном виде. В структуре числа нет информации о знаке числа, поэтому тип и называется — беззнаковый.

Для знакового типа shortint необходимо сохранять информацию о знаке — для этого достаточно одного старшего (первого слева) бита. Если он равен 0, то число — положительное (или равное нулю) и его значения варьируются от 0 до 127, т.е. от 00000000 до 01111111. Если старший бит равен 1, то число — отрицательно, и оставшиеся 7 бит являются разностью между числом 128 и модулем искомого числа (так называемый дополнительный код числа). Например:

-1 11111111
-2 11111110
-3 11111101
-128 10000000
Илон Маск рекомендует:  Что такое код asp @transaction

Остальные целочисленные типы требуют больше, чем 1 байт памяти. Для удобства байты значения в памяти записывают в обратном порядке. Например число 123456 типа integer, которое в двоичном и шестнадцатиричном виде записывается как

в памяти будет представлено в виде

01000000 11100010 00000001 00000000

Чтобы убедиться в том, что байты значения в памяти записываются в обратном порядке можно провести эксперимент. Возьмем у числа 789 (или 0000001100010101) типа word только первый байт, и он должен равняться 21 (или 00010101), а не 3 (или 00000011) при прямом порядке:

begin
A := 789 ;
P := @A; // указатель на область памяти переменной A

WriteLn( A );
WriteLn( PByte(P)^ ); // выводим первый байт области памяти
// на который указывает P
ReadLn;
end .

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

Знак Операция Пример Результат
+ Сложение 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. В конструкции

выражение (a * b) имеет тип integer, а не int64, и значение может переполниться. В этом случае следует привести один из операндов к типу int64. Явное приведение к какому-либо типу описывается следующим образом:


В таком случае, текст программы выглядит так:

Smallint() — поясните пожалуйста тип данных

вот честно не нашел нормального объяснения про типы данных

Smallint() — Диапазон от -32 768 до 32 767 — это ведь диапазон значений.

если да, то как мне указать что в данное поле можно записывать числа от 0 до 1000, я наверняка знаю, что больше 1000 полей у меня не будет..

а можно ввести только значение от 0 до 255 — и сколько это, мне не о чём не говорит

06.04.2012, 15:42

Тип данных record (запись). Помогите пожалуйста!
Задание: В соответствии с индивидуальным вариантом необходимо составить программу для ЭВМ.

Поясните, что это за тип int?
Поясните, что это за тип int? ?

Поясните, пожалуйста.
Что означает «%d» Arr и sizeof в си?

06.04.2012, 21:30 2 06.04.2012, 21:38 [ТС] 3

ну пишу я в консоле
create table mk(
smallint(1000) t);

error: smallint max=255

06.04.2012, 21:53 4 06.04.2012, 22:41 [ТС] 5 07.04.2012, 03:41 6

Из документации по MySQL:

10.1.1. Numeric Type Overview

A summary of the numeric data types follows. For additional information about properties and storage requirements of the numeric types, see Section 10.2, “Numeric Types”, and Section 10.5, “Data Type Storage Requirements”.

M indicates the maximum display width for integer types. The maximum legal display width is 255. Display width is unrelated to the range of values a type can contain, as described in Section 10.2, “Numeric Types”. For floating-point and fixed-point types, M is the total number of digits that can be stored.

The display width does not constrain the range of values that can be stored in the column. Nor does it prevent values wider than the column display width from being displayed correctly. For example, a column specified as SMALLINT(3) has the usual SMALLINT range of -32768 to 32767, and values outside the range permitted by three digits are displayed in full using more than three digits.

т.е. все равно какую ширину поля для smallint указать диапазон используемых значений будет от -32768 to 32767.

Также в документации указано:

(That is, this width is present in the metadata returned with result sets. Whether it is used or not is up to the application.)

т.е если указано width, оно будет присутствовать в метаданных, а вот использовать или нет зависит от приложения

Добавлено через 21 минуту
Вот документация по MySQL на русском:

SmallInt — Тип Delphi

При переходе от Турбо Паскаля к Delphi с данными произошло довольно много изменений. Их основой, без сомнения, стали (как минимум) две важные причины: увеличение в 2-4 раза разрядности процессоров и существенное недовольство программистов некоторыми ограничениями Паскаля, например, принципиальной невозможностью иметь строку более 255 символов. В результате в Delphi не только появились новые типы данных, но и старые (INTEGER, STRING) получили большие возможности.

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

2.1. Целые числа

Центральное новшество в этой области состоит в том, что в Delphi тип INTEGER уже не двух-, а четырехбайтовый 5 , т.е. фактически неотличим от LONGINT в Турбо Паскале! Ради сохранения преемственности в Delphi введен тип SMALLINT, который полностью эквивалентен INTEGER в Турбо Паскале.

А еще для любителей вычислений с большими числами в Delphi добавлен 64-разрядный тип INT64. Полная таблица целочисленных типов приведена ниже.

тип диапазон наличие знака длина (бит)
shortint -128 .. 127 знаковый 8
smallint -32768 .. 32767 знаковый 16
longint (integer) -2147483648 .. 2147483647 знаковый 32
int64 -2 63 .. 2 63 – 1 знаковый 64
byte 0 .. 255 беззнаковый 8
word 0 .. 65535 беззнаковый 16
longword (cardinal) 0 .. 4294967295 беззнаковый 32

Эксперимент 2. Количество байт в INTEGER

Постановка задачи. Убедиться, что тип INTEGER действительно занимает в памяти 4 байта.

Реализация эксперимента. Простейший способ проверить это – задать большое число, для убедительности – 2147483647 (см. таблицу).

Описательная и исполняемая часть программы могут быть, например, следующими (добавьте их к шаблону консольного приложения в соответствии с цветом так, как это сделано в листинге 1 6 ).

Листинг 2

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

Мы видим, что число «воспринимается» и сохраняется, а значит, значение уже не двухбайтовое, а минимум четырехбайтовое. Шестнадцатеричное представление числа (с учетом перестановки байт) – 7F FF FF FF (т.е. 127 255 255 255 в десятичном виде), подтверждает, что перед нами максимальное положительное значение 32-битного целого числа со знаком.

Стоит также провести еще одну дополнительную проверку: увеличить данное максимально допустимое число на единицу и записать test:=2147483648; При попытке трансляции в нижней части окна с текстом программы появится предупреждающее сообщение:

[Warning] int_len.dpr(17): Constant expression violates subrange bounds
(примерный перевод:
[Предупреждение] проект int_len.dpr(строка 17): значение константы нарушает границу допустимого диапазона)

Таким образом, Delphi подсказывает нам, что предел четырехбайтовой величины превышен. Тем не менее, задача запускается (предупреждение – это «небольшая» ошибка), а ответ, как и следовало ожидать, выдается отрицательным.

Наконец, есть и еще один (совсем простой) способ проверки – вывести на экран значение стандартной константы MAXINT и убедиться, что оно равно 2147483647, что соответствует именно четырехбайтовому целому 7 .

Еще рекомендую поэкспериментировать с другими типами целочисленных данных, указанных в таблице, например, LONGINT и SMALLINT.

Выводы. В Delphi значение типа INTEGER хранится не в двух, как в Турбо Паскале, а в четырех байтах; LONGINT в обоих системах программирования совпадают, следовательно, в Delphi INTEGER и LONGINT одно и то же. SMALLINT – новый двухбайтовый тип Delphi, введенный для совместимости с INTEGER в старых реализациях Паскаля.

2.2. Вещественные числа

А в этой области нас ждут еще более радикальные изменения. Тип REAL, к которому мы так привыкли в классическом Паскале, вообще объявлен устаревшим и не рекомендуется к употреблению (хотя и поддерживается ради совместимости под псевдонимом REAL48).

Вместо REAL предлагается использовать другие вещественные типы – SINGLE, DOUBLE и EXTENDED (они есть и в Турбо Паскале). Все они непосредственно опираются на одноименные форматы данных математического сопроцессора, поэтому фактически даже не являются чем-то «сугубо паскалевским». Поскольку все эти важные с практической точки зрения данные оказываются независимыми от языка программирования, есть смысл рассмотреть круг вопросов, которые связаны с вещественными числами, отдельно. Это будет сделано в разделе 3.

Напомню также читателям, что исторически тип REAL был реализован в виде специализированной математической библиотеки Паскаля и не имел аппаратной поддержки.

2.3. Строковые данные

История такова, что в классическом Паскале не было специального строкового типа, а для обработки текста создавался сложный тип данных ARRAY OF CHAR. В более поздних реализациях компиляторов появился тип STRING с большим ассортиментом специализированных процедур и функций для работы с текстами. Программисты по достоинству оценили новые возможности, хотя заложенное в Турбо Паскале принципиальное 255-символьное ограничение (объяснение его появления см., например, в [4]), конечно, создавало трудности для программирования реальных задач.

При переходе к Delphi максимальная длина текста было сдвинута с 255 байт до 2 Гбайт, что для большинства практических (и всех учебных!) задач позволяет вообще забыть о существовании этого ограничения.

Важно понять, что обеспечить хранение переменных такой длины традиционным выделением заранее участка памяти из фиксированного числа байт просто невозможно: при таком подходе потребуется зарезервировать под каждую строковую переменную по 2 Гб ОЗУ, что абсурдно. Как же все-таки решается эта проблема в Delphi (да и в других компиляторах тоже)?

Существует два принципиально разных метода хранения переменных: статический и динамический. Для того, чтобы лучше понять разницу, обратимся к рис. 6, где изображено выделение памяти под статическую (stat) и динамическую (dyn) переменные.
Рис. 6. Статические и динамические переменные

В первом случае при трансляции программы под переменную выделяется одна или несколько ячеек ОЗУ и в этой области памяти позднее будут храниться значения переменной. Фактически везде, где в тексте программы имеется ссылка на данную переменную, компилятор подставляет команды обращения к адресам зарезервированной области памяти. Выделенная под переменную память не может быть использована иначе, чем для хранения значений этой переменной 8 .

Динамический механизм работает совсем по-другому. В момент трансляции под переменную выделяется некоторое место в ОЗУ, которого достаточно только для хранения адреса (почувствуйте разницу: резервируется место не под сами данные, а под адрес, ссылающийся на участок памяти, где находятся данные). Память под данные в этот момент не выделяется – это делается при исполнении программы, когда переменной будет присваиваться конкретное значение. И в этом главный залог успеха: под значение будет отведено ровно столько динамической памяти, сколько требуется 9 .

Применительно к текстам это выглядит так. В Турбо Паскале заранее резервируется память под строку максимально возможной длины, даже если при выполнении программы окажется, что переменная реально будет хранить всего один символ. (Сравните с бланком, где ширина колонки под фамилию всегда рассчитана на самый длинный текст, тогда как некоторые фамилии вроде Ким или Усов можно было бы поместить и в более узкую колонку). В Delphi память под значение выделяется в процессе исполнения, поэтому переменная получает именно столько байтов, какова длина текста. Таким образом, в отличие от увеличения размера чисел INTEGER, описанного в 2.1, удлинение строк потребовало еще и изменения способа организации памяти.

Новый «расширенный» тип STRING называется в Delphi ANSISTRING. Для совместимости существуют также короткие строки SHORTSTRING, полностью воспроизводящие STRING в Турбо Паскале. Описание STRING по умолчанию трактуется как ANSISTRING 10 . Описание STRING[n], где n≤255, генерирует статическую форму SHORTSTRING.

Дополнительно в Delphi имеется еще тип WIDESTRING, созданный для поддержки 16-битной кодировки Unicode.

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

Эксперимент 3. Изучение хранения строк

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


Реализация эксперимента. В листинге 3 показаны описательная и исполняемая часть программы для нашего эксперимента. Описание string[3] обеспечивает статическое выделение памяти под переменную test. В ходе выполнения программы ей присваивается значение ‘A 1’, а затем байты переменной выводятся на экран.

Листинг 3

В результате выполнения эксперимента на экране появятся числа:

Первое из них – это фактическая длина текста. Три следующих – это десятичные(!) коды символов, а остальные нули показывают, что мы вывели слишком много байт. Полученная картина «один к одному» повторяет результаты для Турбо Паскаля [4].

Очень поучительно взглянуть, что получится, если в переменную test попробовать занести более трех символов: результат не изменится, поскольку Паскаль просто игнорирует лишние символы.

Наконец, заменим описание string[3] на string. Тем самым, вместо статической строки получим динамическую, и результат эксперимента будет другим. На моем экране появились числа:

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

Если хватит терпения, можете присвоить динамической переменной test строковое значение, длина которого превышает 255 символов, и напечатать его; для этого добавьте в программу строку writeln(test);

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

2.4. Тип VARIANT

В Delphi появляется принципиально новый тип данных VARIANT, который может помещать внутрь переменной значения разного типа: например, сначала INTEGER, а затем STRING. В классическом Паскале такое вообще невозможно. Кроме того, действия над значениями типа VARIANT выполняются особым образом. Например, если V1 и V2 имеют тип вариант, и V1=12.5, V2=’12’, то V1+V2 будет равно 24.4, потому что строка ’12’ перед сложением будет автоматически преобразована в число.

Рассмотрим кратко, как же устроен это необычный тип данных. Каждая переменная типа VARIANT состоит из 16 байт, причем первая их половина хранит служебную информацию, а вторая – значение переменной или ссылку на это значение. Самые первые 2 байта переменной содержат целое число, характеризующее тип значения, которое в данный момент лежит в переменной. Полный список возможных типов содержит около 20 разных значений, начиная целыми и вещественными числами и кончая символьными значениями и даже массивами. Например, для числа типа INTEGER характеристическое значение равняется 3, для вещественного числа типа DOUBLE – 5, а для STRING – 10016 = 25610. Остальная часть служебной части пока не используется (зарезервирована) и заполняется нулями.

Эксперимент 4. Как устроен тип VARIANT?

Постановка задачи. Изучить, как тип VARIANT хранит в себе разные значения, например, INTEGER и STRING[n].

Реализация эксперимента. Программа для проведения эксперимента приведена в листинге 4.

Листинг 4

В описательной части при первом запуске будем ставить тип INTEGER, а при втором – STRING[3]. В программе по необходимости предусмотрена дополнительная переменная e, в которую вводится значение с клавиатуры. Дело в том, что непосредственно в переменную VARIANT вводить с клавиатуры нельзя, поскольку компьютер не всегда способен однозначно определить, какого именно типа набранное значение (попробуйте, в частности сами догадаться: введенная с клавиатуры последовательность символов «15 3» – это два целых числа, разделенных пробелом, или же строка?)

Хотя тип VARIANT хранится в 16 байтах, в описании указано значение 20. По результатам второго запуска мы увидим, как пригодится этот запас.

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

Итак, запустим программу для целочисленных данных. На экране получатся следующие результаты (для экономии места 7 последних нулей не показаны):

Расшифруем приведенную выдачу на экран. Первая строка содержит число, которое я вводил. Далее выдается число 3, которое, как мы знаем, означает тип INTEGER. Пропуская строку резервных нулей обращаем внимание на следующие 4 байта, которые и есть собственно число. Выпишем его, традиционно переставляя байты, и получим 00 01 00 00; после перевода из шестнадцатеричного представления в десятичное убедимся, что перед нами введенное число.

Теперь заменим описание INTEGER на STRING[3] и запустим программу еще раз. «Протокол работы» выглядит следующим образом.

Прокомментируем содержимое выдачи. Текст «A 1» я набрал по аналогии с листингом 3. В следующей строке вывелась характерная для строкового типа константа 01 00 (байты уже переставлены программно!) Пропускаем резервные нули и видим странные числа. Вспомните предыдущий эксперимент: это не что иное, как ссылка на то место ОЗУ, где лежит строка. И на этом бы все и закончилось, но нам сильно повезло: это самое место ОЗУ оказалось сразу после переменной типа VARIANT и мы его «зацепили»! Отсчитайте 16 чисел, начиная с 1 во второй(!) строке (это 16 байт переменной test), и вы попадете на число 3, которое есть не что иное, как длина введенного текста. И далее знакомые нам десятичные коды введенных символов. Так что это то самое строковое значение, на которое ссылается тип VARIANT.

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

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

<Уже после отправки статьи в редакцию, по совершенно другому поводу родился еще один эксперимент - посмотреть кодирование булевских переменных. Как оказалось, имеющиеся в современных версиях Паскаля логические типы данных могут кодировать TRUE и FALSE по-разному! В частности, в Delphi для boolean в качестве значения true выдается 1, а для longbool — минус 1 (зато во Free Pascal оба значения равны 1). Воистину классики были правы, когда учили, что никогда не следует сводить переменные boolean к числам! Упомянутый проект редакция успела включить в число примеров на диске; вы тоже можете его загрузить и посмотреть (ищите среди примеров раздела 2).>

5 факториал от 8 теперь уже не будет отрицательным, эта неприятность «отложится» до 17!

6 удобно взять за основу файл с листингом 1: тогда в описательной части достаточно заменить тип longint на integer

7 более «мощный» вариант – использовать конструкцию вроде high(smallint)

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

9 те читатели, кто пользовался в программах на Паскале типом «указатель», хорошо представляют данный механизм; возможно, преподаватели со стажем также вспомнили об области string space в языке MSX BASIC

10 если установить директиву компилятора $H–, то установится совместимость со строками Турбо Паскаля

SmallInt — Тип Delphi

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

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

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

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

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

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

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

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

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

Название

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

SmallInt — Тип Delphi

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

Вам необходимо использовать модификатор «packed»:

TMyRecType = packed record

Автор: Steve Schafer

Более новые статьи:

Более старые статьи:

Случайные материалы:

Добавить комментарий

Не использовать не нормативную лексику.

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

ВСЕ КОММЕНТАРИИ МОДЕРИРУЮТСЯ ВРУЧНУЮ, ТАК ЧТО СПАМИТЬ БЕСПОЛЕЗНО!

Предупреждение о сравнении SmallInt с результатом функции Ord

Я сравнивая SmallInt переменный результат Ord функции. Пример:

После этого, следующее предупреждающее сообщение отображается ( W1023 ):

W1023 Сравнивая подписанные и неподписанные типы — округлились оба операнда

Намек на Delphi , на Ord функции говорит , что она должна возвращать SmallInt и поэтому я не могу понять , что вызывает предупреждающее сообщение. (Я искал Ord функцию в System блоке , но я не нашел).

Дальнейшая информация:

  • Я проверяю под Delphi XE7.
  • Под Delphi 2007, тот же код не дает мне никакого предупреждения.


Как сказал Дэвид, Ord() это так называемый «компилятор магия» (или, как они называют это сейчас, «внутренняя» или «псевдо-») функция, то есть не действительная функция, которая вызывается, но только то , что использует синтаксис функции, но распознается компилятором как специальной конструкции и превращена в код непосредственно. То же самое верно и для , например Chr() , Writeln() и т.д. Они , как правило , имеют различные и / или несколько типов параметров или возвращаемые значения , а иногда даже имеют дополнительные элементы синтаксиса.

В документации сказано, о Ord(X) :

Результат является порядковым положением X; его тип является наименьшим стандартным целочисленный тип, который может содержать все значения типа Х.

В Delphi XE7, ‘C’ является WideChar , а возвращаемое значение Ord(‘C’) будет 16 бит без знака типа ( Word ). Smallint будет подписан тип. Вот почему вы получите предупреждение, потому что вы сравниваете знаковое и беззнаковое типа того же размера, так что значения должны быть расширены до следующего большего типа ( Integer ) .

В Delphi 2007, ‘C’ не является WideChar , это AnsiChar , так что результатом Ord(‘C’) является Byte . Там нет необходимости для расширения до следующего большего типа, так как Smallint может содержать все значения Byte , так как может быть повышена до Smallint .

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

4) Язык Delphi. Переменные, константы и их типы (Часть 2)

RpJay

Заблокирован

Теперь пришло время узнать о типах данных, используемых в Delphi. Прежде всего это строки и числа.

Строкой называется последовательность символов, заключённая в одиночные кавычки:
‘это текстовая строка’ Если текст должен содержать сам символ кавычки, то его надо повторить дважды:
‘это » — символ одиночной кавычки’ Строка может быть и пустой, не содержащей символов. Тогда она состоит из двух идущих друг за другом без пробела кавычек. Естественно, строка может состоять и только из одних пробелов.
Самый популярный строковый тип — String. Строка типа String может содержать переменное количество символов объёмом до 2 Гбайт. Если нужно ограничить размер строки фиксированным значением, то после ключевого слова String в квадратных скобках указывается число, определяющее количество символов в строке: String[50]. Более полно

описывается далее.
Одиночный символ имеет тип Char и записывается в виде знака в одиночных кавычках: ‘a’. Есть символы, которые на экране отобразить невозможно, например, символ конца строки (равен #13), символ переноса строки (равен #10). Такие символы записываются в виде их числового кода (в кодировке ANSI), перед которым стоит знак #. Например, #0.
Наконец, существуют так называемые нуль-терминированные строки. Отсчёт символов в таких строках начинается с нуля, а заканчивается символом с кодом (#0). Такие строки имеют тип PChar.

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

Integer -2147483648 .. +2147483647
Cardinal 0 .. 4294967295
Shortint -128 .. +127
Smallint -32768 .. +32767
Int64 -263 .. +263-1
Byte 0 .. +255
Word 0 .. +65535
Наиболее удобным для использования в программах является тип Delphi Integer. Другие целые типы используются для уменьшения места, занимаемого данными в памяти компьютера.

Дробные числа имеют дробную часть, отделяемую десятичной точкой. Допускается использование символа e (или E), за которым следует число, указывающее, что левую часть нужно умножить на 10 в соответствующей степени: 5e25 — пять умножить на десять в двадцать пятой степени.
Ниже приведены стандартные типы дробных чисел и соответствующие им диапазоны допустимых значений. Для большинства типов указан диапазон положительных значений, однако допустимым является аналогичный диапазон отрицательных значений, а также число .

Real 5*10-324 .. 1.7*10308
Real48 2.9*10-39 .. 1.7*1038
Singl 1.5*10-45 .. 3.4*1038
Double 5*10-324 .. 1.7*10308
Extended 3.6*10-4951 .. 1.1*104932-1
Comp -263 .. +263-1
Currency 922337203685477.5807
Наиболее удобным для использования в программах является тип Delphi Real. Ему эквивилентен тип Double, но в будущем это может быть изменено. Вычисления с дробными числами выполняются приближённо, за исключением типа Currency(финансовый), который предназначен для минимизации ошибок округления в бухгалтерских расчётах.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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