Cardinal — Тип 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. Сделайте выводы.

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

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

Cardinal — Тип 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 в двоичном виде. В структуре числа нет информации о знаке числа, поэтому тип и называется — беззнаковый.

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

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

-1 11111111
-2 11111110
-3 11111101
-128 10000000

Остальные целочисленные типы требуют больше, чем 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. Явное приведение к какому-либо типу описывается следующим образом:

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

Почему тип Cardinal в моей заявке изменился?

У меня есть программа, которая отлично работала в Delphi 3, которую я скомпилировал и протестировал на Turbo Delphi 2006 и обнаружил проблему. Проблема заключается в следующем: я использовал «кардинальные» типы данных в качестве индекса для чего-то. Это работало в Delphi 3, но я обнаружил, что значения были больше, чем они должны быть в скомпилированной версии Turbo Delphi 2006, примерно на 128-256 или около того, в зависимости от конкретных данных. Изменение этих типов данных на longint устранило проблему, поэтому программа работала корректно с обоими компиляторами.

Вопрос: почему это так?

Насколько я понимаю, типы данных Cardinal были просто типичными целочисленными данными без знака. Это согласуется с их применением в этой программе, особенно это подтверждается тем фактом, что компиляция Delphi 3 работала правильно. Так почему же не работает сборка Turbo Delphi 2006?

1 ответ

В Delphi неподписанные типы являются просто поддиапазонными типами следующего более крупного подписанного типа. В Delphi 3 нет 64-битного типа, поэтому нет более крупного типа для кардинала, который будет поддиапазоном. Кардинал является подписанным типом в Delphi 3 из-за технических ограничений в языке. Delphi 4 представил Int64, а Cardinal был создан как неподписанный поддиапазон этого типа (а затем было ограничение, что 64-битный тип не был без знака).

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

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

Delphi XE4 E2010 Несовместимые типы: «Кардинал» и «Указатель»

Здравствуйте, я пытался скомпилировать образец разработки dll firedac в delphi xe4 и придумал следующую ошибку


Я отметил, где ошибка в коде.

Единицей 1 является исполняемый файл.

Unit2, который является dll

database dll delphi firedac anydac

1 ответ

3 Решение Andrei Galatyn [2013-09-01 10:54:00]

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

Типы данных 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.

Символьный тип 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. Движемся дальше.

Why has the Cardinal type in my application changed?

I have a program here which was working fine in Delphi 3 that I compiled and tested on Turbo Delphi 2006 and found a problem. The problem is this: I was using «cardinal» data types as an index for something. It worked in Delphi 3, but I found values were greater than they should be in the Turbo Delphi 2006 compiled version by about 128-256 or so depending on the specific data. Changing these data types to «longint» fixed the problem so the program worked correctly with both compilers.

Илон Маск рекомендует:  Классы в CSS

The question: Why is this?

My understanding was that Cardinal data types were just typical unsigned integer data. This is consistent with the application of them in this program, especially proved by the fact that the Delphi 3 compilation worked correctly. So why did the Turbo Delphi 2006 compilation not work?

Чем LongWord отличается от Cardinal?

Alexeis, не совсем так.

В Delphi беззнаковые целые представлены фундаментальными типами Byte(N=8), Word(N=16) и LongWord(N=32).

Фундаментальными называются те типы данных, разрядность которых не зависит от аппаратной платформы. Кроме них существуют еще общие (generic) типы, разрядность которых определяется разрядностью платформы. В Delphi это типы Integer (знаковое число) и Cardinal (беззнаковое число). В имеющейся реализации они имеют 32 разряда, но при переходе на 64-разрядные компилияторы следует ожидать, что эти типы также станут 64-разрядными. В частности в Turbo Pascal тип Integer был 16-разрядным(а типа Cardinal не было).

Цитата (А.Б. Григорьев «О чем не пишут в книгах по Delphi»)
Цитата (Alexeis @ 12.9.2008, 07:59 )
Integer в платформе 64 остается 32х разрядным, а LongInt станет 64х

Ээээ. мы о Delphi говорим?
Где вы нашли Delphi для win64?

LongWord — это длинное слово (перевод). Байт — это байт, слово — это 2 байта, соответственно, длинное слово — это 4 байта. По определению. Иначе и быть не может. Цитата выше всё верно говорит.

Я не ошень знаком с Сями, но не может ли быть так, что вы ведёте речь о просто long? Тогда здесь нет привязки к слову, и, следовательно, размерности.

Цитата (CodeMonkey @ 12.9.2008, 08:05 )
Где вы нашли Delphi для win64?

В проекте. 2009я должна была быть с поддержкой x64, но ребята не успели, потому ожидаем в будущей версии.

Цитата (CodeMonkey @ 12.9.2008, 08:05 )
LongWord — это длинное слово (перевод). Байт — это байт, слово — это 2 байта, соответственно, длинное слово — это 4 байта. По определению.

Где это определение?
LongWord — говорит о том что он должен быть по размеру не меньше чем Word. 8 байт это не меньше чем 2.

Цитата (CodeMonkey @ 12.9.2008, 08:05 )
Я не ошень знаком с Сями, но не может ли быть так, что вы ведёте речь о просто long?
Цитата (Alexeis @ 12.9.2008, 09:42 )
В проекте.

А вы работаете в CodeGear, чтобы утверждать что-то о продукте, который ещё только находится в разработке? ;)

Цитата (Alexeis @ 12.9.2008, 09:42 )
Где это определение?
Цитата (Delphi help system)
The generic integer types are Integer and Cardinal; use these whenever possible, since they result in the best performance for the underlying CPU and operating system.

In general, arithmetic operations on integers return a value of type Integer—which, in its current implementation, is equivalent to the 32-bit Longint.

Цитата (CodeMonkey @ 12.9.2008, 09:26 )
А вы работаете в CodeGear, чтобы утверждать что-то о продукте, который ещё только находится в разработке? ;)

А вы верите только тому что сами делаете? С такими идеями можно считать что земля имеет форму чемодана потому что я ее не видел из космоса своими глазами, а все фотки подделки и все кто говорят что это шар врут.

Поддержка x64 RTL Delphi + C++ Builder в Roadmape с 2006 го года. Сначала предполагалось ввести в версии «Highlander», потом «Tiburon», сейчас отложили до «Commodore», т.е. до следующей версии.

Значит перерыл пол инета. Касательно делфи типов в Delphi x64 нет ни какой инфы.
Есть тока два предположения.
1е будет точно также как в FreePascal т.е.

Type Range Size in bytes

Shortint -128 .. 127 1


Smallint -32768 .. 32767 2

Word 0 .. 65535 2

Integer either smallint, longint or int64 size 2,4 or 8

Cardinal either word, longword or qword size 2,4 or 8

Longint -2147483648 .. 2147483647 4

Longword 0..4294967295 4

Int64 -9223372036854775808 .. 9223372036854775807 8

QWord 0 .. 18446744073709551615 8

И второе. Они обещают ввести одновременно в Delphi и C++ Builder. Т.е. будут делать общую RTL и согласованную систему типов. Тип Integer всегда соответствовал типу int, который остается 32х битным в системе х64. Кроме того есть тенденция полного согласования Delphi.NET и Delphi for Win32 чтобы можно правильно переносить программы «Delphi.NET» «Delphi for Win32» с минимальными исправлениями. В связи с этими соображениями ни как не согласуется 64х битный Integer.

Цитата (CodeMonkey @ 12.9.2008, 09:26 )
Первое недвусмысленно говорит о том, что общие типы Integer и Cardinal меняются так, чтобы соответствовать родному типу CPU

Эта фраза из старого хелпа, относилась скорее всего еще к переходу с MSDOS

Цитата (CodeMonkey @ 12.9.2008, 09:26 )
Второе говорит о том, что Integer равен LongInt только в текущей реализации компилятора.

Так тут нет противоречия скорее всего Integer будет 32х битным LongInt и Cardinal 64х разрядными.

Цитата (Alexeis @ 12.9.2008, 11:12 )
А вы верите только тому что сами делаете?

Вот вы всё это сейчас к чему говорите? Вы сделали необоснованное и ничем не подтверждённое заявление («Integer в платформе 64 остается 32х разрядным, а LongInt станет 64х»). Мои же слова подтверждаются официальной документацией (а, следовательно, и официальной позицией) и историей развития Паскаля вообще.

Цитата (Alexeis @ 12.9.2008, 11:12 )
Поддержка x64 RTL Delphi + C++ Builder в Roadmape с 2006 го года. Сначала предполагалось ввести в версии «Highlander», потом «Tiburon», сейчас отложили до «Commodore», т.е. до следующей версии.
Цитата (Alexeis @ 12.9.2008, 11:12 )
В связи с этими соображениями ни как не согласуется 64х битный Integer.

Не вижу несогласованности. Ключевое слово здесь — type1 mapped to type2. Т.е. соответствие. Соответствие на то и есть соответствие, что может меняться. Integer сейчас, вон, тоже на LongInt замаппен. Ну и что? Это же не значит, что это одно и тоже. Вот если бы были такие слова, как: «Integer — это ровно и есть <какой-то тип C++ или .NET>» (вы уж простите, не спец я в них), то это было бы другое дело. Но сказано, что типы соответствуют друг другу. Чуете разницу? В Delphi for Win64 просто будет другой маппинг, вот и всё. Ровно так же, как отличаетсяся маппинг в D1 и D2.

Цитата (Alexeis @ 12.9.2008, 11:12 )
Эта фраза из старого хелпа, относилась скорее всего еще к переходу с MSDOS

Эта фраза — из хэлпа к D2007, который использую я.

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

Цитата (CodeMonkey @ 12.9.2008, 11:46 )
необоснованное и ничем не подтверждённое заявление
Цитата (CodeMonkey @ 12.9.2008, 10:46 )
Цитата(Alexeis @ 12.9.2008, 11:12 Найти цитируемый пост)

Поддержка x64 RTL Delphi + C++ Builder в Roadmape с 2006 го года. Сначала предполагалось ввести в версии «Highlander», потом «Tiburon», сейчас отложили до «Commodore», т.е. до следующей версии.

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

Цитата (CodeMonkey @ 12.9.2008, 10:46 )
Не вижу несогласованности. Ключевое слово здесь — type1 mapped to type2. Т.е. соответствие. Соответствие на то и есть соответствие, что может меняться. Integer сейчас, вон, тоже на LongInt замаппен. Ну и что? Это же не значит, что это одно и тоже. Вот если бы были такие слова, как: «Integer — это ровно и есть <какой-то тип C++ или .NET>» (вы уж простите, не спец я в них), то это было бы другое дело. Но сказано, что типы соответствуют друг другу. Чуете разницу? В Delphi for Win64 просто будет другой маппинг, вот и всё. Ровно так же, как отличаетсяся маппинг в D1 и D2.

С++ Builder компилирует не только С++ код, но и Delphi код используя общие части RTL и VCL. Сейчас С++ int определен как Integer, если при переходе Integer станет 64 битным (int не сможет стать 64х битным), то создателям Билдера прийдеться полностью переписать весь код заменяя int на long, и соответственно везде где приводились одноразмерные типы теперь невозможно преобразование, потому что тип int заменили для соответствия с VCL и тип к которому приводили нужно заменить на тип большего размера. Уйдут в горы тысячи написанных компонентов для билдера.

CodeMonkey, это будет далеко не тоже что просто взять сказать что типу Integer теперь соответствует long. Если ПО было написано грамотно (используя в нужных местах типы фиксированного размера), то перенос должен осуществиться гладко без полного переписывания.

Цитата (CodeMonkey @ 12.9.2008, 10:46 )
С моей точки зрения, единственная причина оставить как есть — совместимость.

Это весьма весомая причина. Кстати в С++ типы int и long тоже архитектурозависимые, но при этом long вырос, а int, остался таким. Вероятно на то есть очень веские основания. Логично предположить, что исходя из этих же оснований поменяются типы в Delphi.
Вспоминаем дальше переход c 16 разрядной на 32х разрядную.
C++
int 16 -> int 32
long 32 -> long 32

Delphi
Integer 16 -> Integer 32
LongInt 32 -> Longint 32

А теперь задумаемся почему это было сделано. integer мог содержать число 65 тыщ, обрабатывался за одну операцию, но этого явно было недостаточно для вычислений, поскольку не так много реальных величин укладывалось в этот диапазон. Нужен был целый тип большей разрядности, им был Longint, но вместе с этим вычисления с типом Longint производятся в 2 раза медленнее. Указатели не влазят в регистр и обрабатываются в 2 такта

Переходим на платформу 32. Наконец Integer можно расширить до 2х мрд. и нормально работать не теряя в скорости. Вопрос нехватки диапазона снят, потому нет смысла расширять Longint, и замедлять скорость. Для тех кому все же нужны большие числа ввели сравнительно редкий тип int64. Наконец, указатель влез в регистр. Ура у нас 32х разрядные регистры позволяющие за раз оперировать указателем за раз.

Переходим на платформу 64. Диапазон 2млрд. по прежнему устраивает большинство народу, скорость обработки int32 не медленнее чем int64, зато памяти теперь нужно в 2 раза больше + поплыли все структуры. Вреда больше чем пользы. Longint — теперь можно увеличить в 2 раза не теряя в производительности. Удобно! большой диапазон, а скорость как у Integer.
Указатели. Собственно ради этого и лезли в x64 наконец можно адресовать больше 2х Гб и при этом оставаться в пределах одного регистра.

Вот такие соображения. Потому есть уверенность процентов на 95 что именно так все и будет.

Delphi in a Nutshell by Ray Lischner

Stay ahead with the world’s most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to v > Start Free Trial

No credit card required

Syntax

Description

The Cardinal type is an unsigned integer subrange whose size is the natural size of an integer. In Delphi 5, the size is 32 bits, but in future versions of Delphi, it might be larger. Use LongWord for an unsigned integer type that must be 32 bits, regardless of the natural size of an integer. See the Integer type for information about other integer types.

Tips and Tricks

The most common use for Cardinal is calling Windows API or other external functions that take parameters of type DWORD (unsigned long in C or C++).

If you need an integer type for natural or whole numbers, you should usually define your own subranges, as shown here:

Using Cardinal as an ordinary integer type often gives results different from what you expect because the result might be any Integer or Cardinal value. The range of values covered by each indiv >Integer and Cardinal values forces the compiler to expand the operands to at least 33 bits—so Delphi converts the operands to the Int64 type:

Delphi in a Nutshell by Ray Lischner

Stay ahead with the world’s most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to v > Start Free Trial

No credit card required

Syntax

Description

The Cardinal type is an unsigned integer subrange whose size is the natural size of an integer. In Delphi 5, the size is 32 bits, but in future versions of Delphi, it might be larger. Use LongWord for an unsigned integer type that must be 32 bits, regardless of the natural size of an integer. See the Integer type for information about other integer types.

Tips and Tricks

The most common use for Cardinal is calling Windows API or other external functions that take parameters of type DWORD (unsigned long in C or C++).

If you need an integer type for natural or whole numbers, you should usually define your own subranges, as shown here:

Using Cardinal as an ordinary integer type often gives results different from what you expect because the result might be any Integer or Cardinal value. The range of values covered by each indiv >Integer and Cardinal values forces the compiler to expand the operands to at least 33 bits—so Delphi converts the operands to the Int64 type:

Почему тип Cardinal в моей заявке изменился?

У меня есть программа, которая отлично работала в Delphi 3, которую я скомпилировал и протестировал на Turbo Delphi 2006 и обнаружил проблему. Проблема заключается в следующем: я использовал «кардинальные» типы данных в качестве индекса для чего-то. Это работало в Delphi 3, но я обнаружил, что значения были больше, чем они должны быть в скомпилированной версии Turbo Delphi 2006, примерно на 128-256 или около того, в зависимости от конкретных данных. Изменение этих типов данных на longint устранило проблему, поэтому программа работала корректно с обоими компиляторами.

Вопрос: почему это так?

Насколько я понимаю, типы данных Cardinal были просто типичными целочисленными данными без знака. Это согласуется с их применением в этой программе, особенно это подтверждается тем фактом, что компиляция Delphi 3 работала правильно. Так почему же не работает сборка Turbo Delphi 2006?

1 ответ

В Delphi неподписанные типы являются просто поддиапазонными типами следующего более крупного подписанного типа. В Delphi 3 нет 64-битного типа, поэтому нет более крупного типа для кардинала, который будет поддиапазоном. Кардинал является подписанным типом в Delphi 3 из-за технических ограничений в языке. Delphi 4 представил Int64, а Cardinal был создан как неподписанный поддиапазон этого типа (а затем было ограничение, что 64-битный тип не был без знака).

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

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

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