2009-06-15 17 views
12

Delphi siempre ha admitido algunos tipos numéricos básicos y me preguntaba cómo se relacionan entre sí.¿Cómo se relacionan los tipos básicos de Delphi entre sí?

En Delphi 2007 me encontré con estas declaraciones (algunas son contradictorios, algunos son meros aliasses):

Types.pas:

DWORD = LongWord; 
Largeint = Int64; 

getmem.inc:

DWORD = Integer; 

Windows. pas:

DWORD = Types.DWORD; 
SHORT = Smallint; 
UINT = LongWord; 
ULONG = Cardinal; 
LONGLONG = Int64; 
TLargeInteger = Int64; 
ULONGLONG = UInt64; 

Esto me lleva a pensar que los tipos numéricos con signo base son SmallInt, Integer e Int64. Sin firmar, hay Byte, WORD y UInt64. Pero, ¿cuál es la diferencia entre Cardinal y LongWord? (Por cierto, ¿cuál es la carcasa original y prevista para estos tipos?)

¿Y hay un tipo de enteros de 8 bits con signo (Int8)?

// Int8 = ?unknown?; 
UInt8 = Byte; 
Int16 = SmallInt; 
UInt16 = Word; 
Int32 = Integer; 
UInt32 = LongWord; 
// Int64 already exists 
// UInt64 already exists 

Por último, ¿cómo debería definir int y uint, especialmente con respecto a C/C++ compatibilidad y un futuro cambio a otras plataformas (posiblemente también 64 bits)? (Una cuestión relacionada es, por supuesto, cómo se definirá los distintos tipos numéricos de 64 bits de Delphi?)

+1

Gracias por todos los comentarios, lo que he aprendido de esto es que los tipos básicos como UInt8 y todas las variantes deberían haberse usado como, ¡bueno, lo básico! Sería bueno que una futura versión de Delphi (o FPC) cambiara sus declaraciones de tipo, de modo que los tipos no tan básicos se derivan claramente de los conceptos básicos. Esperaría ver algo como esto en Types.pas o System.pas: tipo Entero = {$ IFDEF CPU64} Int64 {$ ELSE} Int32 {$ ENDIF}; Apenas mis 5 centavos, sin embargo. – PatrickvL

Respuesta

7

El tipo entero de un byte firmado es ShortInt. Puede recordar su tamaño por el hecho de que es no del mismo tamaño que las implementaciones habituales de C del tipo short.

En cuanto a las mayúsculas, marque con mayúscula la primera letra. The documentation tiende a dejar la parte "int" al final en minúscula, como en Entero largo, pero creo que es más común capitalizarlo. No escriba los tipos en todas las mayúsculas a menos que esté usando los tipos de Platform SDK y que desea que su código muestre sus raíces en C; de lo contrario estaría simplemente escribo Word y DWord, Long y ULong, etc.)

Delphi 2009, quizás antes, ya se define como tipos Int8 y UInt32. En cuanto a cómo definir Int y UInt, diría no. El idioma que está utilizando ya define Integer y Cardinal; no introduzca nuevos nombres cuando no sea necesario. Guarde los nombres que ya tiene, y luego todos los demás sabrán de lo que está hablando. (Además, Int es ya una función en la unidad Sistema.)

Uso Cardinal cuando se desea un tipo sin firmar y no se preocupan por su tamaño; use LongWord cuando la variable debe tener exactamente cuatro bytes. Del mismo modo para Integer y LongInt. Use Cardinal cuando desee un tipo de cuatro bytes sin firmar; use LongWord cuando desee un tipo genérico sin firmar y no le importe el tamaño. Del mismo modo para Integer y LongInt, hoy en día. Si está escribiendo código de 16 bits, use LongInt cuando necesite cuatro bytes y use Integer cuando no le importe el tamaño; Cardinal y LongWord no existían en los días de 16 bits de Delphi y Turbo Pascal.

La sabiduría común durante años fue que Integer y Cardinal se convertirían en tipos de 64 bits en un compilador de 64 bits, pero aparentemente ese no es el caso. En cambio, they will remain 32-bit types, al igual que sus contrapartes en Microsoft C++. Además, habrá un nuevo tipo, NativeInt, que será un tipo de 64 bits en un compilador de 64 bits. Los tipos LongInt y LongWord se convertirán en tipos de 64 bits porque siempre han tenido el mismo tamaño que el tipo Pointer, que era de 32 bits incluso en tiempos de 16 bits.

+1

"Los tipos LongInt y LongWord se convertirán en tipos de 64 bits". Eso es algo que se discutió y no se encontró consenso, especialmente porque se anunciaron como los tipos de 32 bits no genéricos desde los días de TurboPASCAL. Y punteros en la tierra de 16 bits donde 20 bits de gran tamaño no 32 bits: "(Seg16 << 4) + Ofs16)" –

+1

Los punteros eran de 32 bits en el sentido de que SizeOf (Puntero) = 4. Nunca ha sido el caso que SizeOf (Puntero) = 2.5. –

+0

... y un entero de 16 bits en TP. –

4
UInt8 = Byte 
Int8 = ShortInt 
UInt16 = Word 
Int16 = SmallInt 
UInt32 = LongWord 
Int32 = LongInt 
UInt64 = UInt64 
Int64 = Int64 

int = Integer 
uint = Cardinal 

NativeInt (generic, depends on CPU register size) 
NativeUInt (generic, depends on CPU register size) 

cardenal y de enteros son tipos genéricos. Para 16 bits tenían 16 bytes de gran tamaño y 32 bits tenían 32 bits de ancho. Para 64 bits, la plataforma de 64 bits de Windows (LLP64) los define como de 32 bits. Los nuevos tipos NativeInt y NativeUInt son ahora los tipos de tamaño de registro de la CPU.

+1

Gracias por mencionar LLP64, lo que me llevó a este artículo: http://en.wikipedia.org/wiki/64-bit#Specific_data_models Increíble la cantidad de cosas que uno puede olvidar ... ;-) – PatrickvL

+0

FPC define 64- bit unsigned como QWORD. –

3

Cardinal y Entero son alias.

Cardinal ==> LongWord (unsigned) 
Integer ==> LongInt (signed) 

http://i38.tinypic.com/9s5ufc.jpg

+0

¡Incorrecto! LongWord = cardinal = DWORD = ** unsigned ** entero de 32 bits, –

+0

Whoops, tenía los nombres intermedios invertidos (corregidos). La idea externa es correcta 'Integer' es un alias para un' Int32', 'Cardinal' es un alias para un' UInt32' (para usar la terminología .NET más clara) –

2

llegar "el original y pretende carcasa" presione Ctrl - espacio,Retorno después de teclear un nombre de tipo (es decir, el uso de finalización de código).

Cuestiones relacionadas