Версия для печати темы
Нажмите сюда для просмотра этой темы в оригинальном формате
Форум программистов > Delphi: Для новичков > Чем LongWord отличается от Cardinal?


Автор: Rohoss 11.9.2008, 20:09
Чем LongWord отличается от Cardinal? Что значит размер (типа Cardinal) не гарантируется?

Автор: Alexeis 11.9.2008, 20:47
  Сейчас LongWord = Cardinal по определению. В 64х разрядной системе LongWord по идее будет 64х битным а вместе с ним и Cardinal.

Автор: VICTAR 12.9.2008, 04:58
Alexeis, не совсем так.

Цитата(А.Б. Григорьев "О чем не пишут в книгах по Delphi")

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

PS всем советую почитать эту книгу, там есть очень занятные вещи

Автор: Alexeis 12.9.2008, 07:59
VICTAR, это тока теоретически, но на самом деле Integer в платформе 64 остается 32х разрядным, а LongInt станет 64х. Не забывай что Integer = Int32(.NET) да и в C++ тип int не бывает 64х разрядным, он бывает тока 16 и 32х. Наскока мне известно лонги должны стать 64х разрядными.(по крайней мере так в С++)

Автор: CodeMonkey 12.9.2008, 09:05
Цитата(Alexeis @  12.9.2008,  07:59 Найти цитируемый пост)
Integer в платформе 64 остается 32х разрядным, а LongInt станет 64х

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

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

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

Автор: Alexeis 12.9.2008, 09:42
Цитата(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?

  В С++ к перед типами можно ставить  long. long int, получается точно такой же тип как в делфях LongInt. Вообще, типы С++ и Delphi находятся в согласовании из-за общих соображений к именованию и размерности типов платформы. 

Автор: CodeMonkey 12.9.2008, 10:26
Цитата(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.

Первое недвусмысленно говорит о том, что общие типы Integer и Cardinal меняются так, чтобы соответствовать родному типу CPU (т.е. 4 байта на 32x и 8 байт на 64x).
Второе говорит о том, что Integer равен LongInt только в текущей реализации компилятора.
Хотите сказать, врут? smile))

Автор: Alexeis 12.9.2008, 11:12
Цитата(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
Byte  0 .. 255  1
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.

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

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

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

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



Автор: CodeMonkey 12.9.2008, 11:46
Цитата(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. 
С моей точки зрения, единственная причина оставить как есть - совместимость. Большая часть кода совершенно не видит разницы между этими типами и использует их как попало. Если поменять разрядность любого из типов в любую сторону, старый код поплывёт.

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

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

Автор: Alexeis 12.9.2008, 14:21
Цитата(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 что именно так все и будет.

Автор: CodeMonkey 12.9.2008, 14:34
Цитата(Alexeis @  12.9.2008,  14:21 Найти цитируемый пост)
это будет далеко не тоже что просто взять сказать что типу Integer теперь соответствует long. Если ПО было написано грамотно (используя в нужных местах типы фиксированного размера), то перенос должен осуществиться гладко без полного переписывания. 

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

Цитата(Alexeis @  12.9.2008,  14:21 Найти цитируемый пост)
 Вот такие соображения. Потому есть уверенность процентов на 95 что именно так все и будет.

Посмотрим, время покажет. Может вообще будет как с real-ом и строками - определение типа задаётся директивами.

Автор: Alexeis 12.9.2008, 15:00
Цитата(CodeMonkey @  12.9.2008,  13:34 Найти цитируемый пост)
Если руководствоваться такой логикой, то все старые типы должны остаться без изменений, а вводится новые. 

   Только то там где это оправдано эффективностью и пользой. Нас ожидает куча траблов с указателями (надеюсь тут нет сомнений что они будут 64х разрядными), но зато теперь решен наболевший вопрос нехватки адресного пространства. Ведь не трогали же LongInt при переходе на 32 разряда, хотя по логике он должен был быть длинее Integer. Тип real, вообще был не нативным. Так же как comp и currency. Ими можно крутить как угодно, речь они по любому работают медленнее нативных. 

Автор: CodeMonkey 9.12.2008, 10:59
Кстати, вот здесь: http://dn.codegear.com/article/39076 есть интересные слова: вместо generic-типов Integer и Cardinal в Delphi теперь вводятся NativeInt и NativeUInt:

Цитата
The NativeInt and NativeUInt types, which should depend on the compiler version (32 bit and future 64 bit) were already in Delphi 2007, but, they were not documented.
If you need a data type that will match the CPU native integer size, these are the types to use.
The Integer type, in fact, is expected to remain unchanged when moving from 32-bit to 64-bit compilers.


Встроенные в компилятор типы выглядят так:
Цитата
ShortInt       Byte
SmallInt       Word
Integer       Cardinal
NativeInt       NativeUInt
Int64       UInt64


Плюс предлагается использовать следующие типы, вместо классических:
Цитата
Int8 = ShortInt;
Int16 = SmallInt;
Int32 = Integer;
UInt8 = Byte;
UInt16 = Word;
UInt32 = Cardinal;

Powered by Invision Power Board (http://www.invisionboard.com)
© Invision Power Services (http://www.invisionpower.com)