Delphi has long supported a few basic numeric types and I was wondering how they are related to each other.
In Delphi 2007 I found these declarations (some are conflicting, some are mere aliasses) :
DWORD = LongWord; Largeint = Int64;
DWORD = Integer;
DWORD = Types.DWORD; SHORT = Smallint; UINT = LongWord; ULONG = Cardinal; LONGLONG = Int64; TLargeInteger = Int64; ULONGLONG = UInt64;
This leads me into thinking the base signed numeric types are SmallInt, Integer and Int64. Unsigned, there's Byte, WORD and UInt64. But what is the difference between Cardinal and LongWord? (By the way, what's the original and intended casing for these types?)
And is there a type for signed 8 bit integers (Int8)?
// Int8 = ?unknown?; UInt8 = Byte; Int16 = SmallInt; UInt16 = Word; Int32 = Integer; UInt32 = LongWord; // Int64 already exists // UInt64 already exists
Lastly, how should I define Int and UInt, especially with regard to C/C++ compatibility and a future switch to other platforms (possibly also 64 bit)? (A related question is, of course, how will the various numeric types be defined in 64-bit Delphi?)
Any way to authenticate with a websense server from delphi?
Delphi Printer.Printers not refreshing
How to add buttons created at runtime into an array?
You can remember its size by the fact that it's not the same size as usual C implementations of the
Fade in an alpha-blended PNG form in Delphi
As for capitalization, capitalize the first letter.
Is there a way to store a Delphi form in a .dll file?
The documentation tends to leave the "int" part at the end lowercase, as in Longint, but I think it's more common to capitalize it.
Modify an Excel Shape from Delphi
Don't write the types in all capitals unless you're using Platform SDK types and you want your code to show its C roots; otherwise I'd just write
Object orientation and serialization
Delphi 2009, perhaps earlier, already defines types like
Get an instance of a persistent object, given the identifier in string
As for how to define
UInt, I'd say don't.
The language you're using already defines
Cardinal; don't introduce new type names when you don't have to.
Keep the names you already have, and then everyone else will know what you're talking about.
Intis already a function in the System unit.).
Cardinalwhen you want an unsigned type and don't care about its size; use
LongWordwhen the variable must be exactly four bytes.
Cardinalwhen you want a four-byte unsigned type; use
LongWordwhen you want a generic unsigned type and don't care about the size.
If you're writing 16-bit code, use
LongIntwhen you need four bytes and use
Integerwhen you don't care about the size;
LongWorddidn't exist in Delphi's and Turbo Pascal's 16-bit days.. The common wisdom for years had been that
Cardinalwould become 64-bit types on a 64-bit compiler, but that is apparently not the case.
Instead, they will remain 32-bit types, just as their counterparts in Microsoft C++ do.
Furthermore, there will be a new type,
NativeInt, which will be a 64-bit type in a 64-bit compiler.
LongWordtypes will become 64-bit types because they have always been the same size as the
Pointertype, which was 32 bits even in 16-bit times..
Cardinal and Integer are generic types.
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)
For 16 bit they were 16 byte large and for 32 bit they are 32 bit large.
For 64 bit the Windows 64bit platform (LLP64) defines them as 32 bit.
The new NativeInt and NativeUInt types are now the CPU register sized types..
Cardinal ==> LongWord (unsigned) Integer ==> LongInt (signed)
use code completion)..