[Home]
[Search]
[D]
Last update Aug 22, 2003
Types
Basic Data Types
void | no type
|
bit | single bit
|
byte | signed 8 bits
|
ubyte | unsigned 8 bits
|
short | signed 16 bits
|
ushort | unsigned 16 bits
|
int | signed 32 bits
|
uint | unsigned 32 bits
|
long | signed 64 bits
|
ulong | unsigned 64 bits
|
cent | signed 128 bits (reserved for future use)
|
ucent | unsigned 128 bits (reserved for future use)
|
float | 32 bit floating point
|
double | 64 bit floating point
|
real
| largest hardware implemented floating
point size (Implementation Note: 80 bits for Intel CPU's)
|
ireal
| a floating point value with imaginary type
|
ifloat
| imaginary float
|
idouble
| imaginary double
|
creal
| a complex number of two floating point values
|
cfloat
| complex float
|
cdouble
| complex double
|
char unsigned 8 bit UTF-8
| wchar unsigned 16 bit UTF-16
| dchar unsigned 32 bit UTF-32
| | | |
Derived Data Types
User Defined Types
- alias
- typedef
- enum
- struct
- union
- class
Pointer Conversions
Casting pointers to non-pointers and vice versa is not allowed in D.
This is to prevent casual manipulation of pointers as integers,
as these kinds of practices can play havoc with the garbage
collector and in porting code from one machine to another. If it is
really, absolutely, positively necessary to do this, use a union,
and even then, be very
careful that the garbage collector won't get botched by this.
Implicit Conversions
D has a lot of types, both built in and derived.
It would be tedious to require casts for every
type conversion, so implicit conversions step in
to handle the obvious ones automatically.
A typedef can be implicitly converted to its underlying
type, but going the other way requires an explicit
conversion. For example:
typedef int myint;
int i;
myint m;
i = m; // OK
m = i; // error
m = (myint)i; // OK
Integer Promotions
The following types are implicitly converted to int:
bit
byte
ubyte
short
ushort
enum
Typedefs are converted to their underlying type.
Usual Arithmetic Conversions
The usual arithmetic conversions convert operands of binary
operators to a common type. The operands must already be
of arithmetic types.
The following rules are applied
in order:
- Typedefs are converted to their underlying type.
- If either operand is extended, the other operand is
converted to extended.
- Else if either operand is double, the other operand is
converted to double.
- Else if either operand is float, the other operand is
converted to float.
- Else the integer promotions are done on each operand,
followed by:
- If both are the same type, no more conversions are done.
- If both are signed or both are unsigned, the
smaller type is converted to the larger.
- If the signed type is larger than the unsigned
type, the unsigned type is converted to the signed type.
- The signed type is converted to the unsigned type.
Delegates
There are no pointers-to-members in D, but a more useful
concept called delegates are supported.
Delegates are an aggregate of two pieces of data: an
object reference and a function pointer. The object reference
forms the this pointer when the function is called.
Delegates are declared similarly to function pointers,
except that the keyword delegate takes the place
of (*), and the identifier occurs afterwards:
int function(int) fp; // fp is pointer to a function
int delegate(int) dg; // dg is a delegate to a function
The C style syntax for declaring pointers to functions is
also supported:
int (*fp)(int); // fp is pointer to a function
A delegate is initialized analogously to function pointers:
int func(int);
fp = &func; // fp points to func
class OB
{ int member(int);
}
OB o;
dg = &o.member; // dg is a delegate to object o and
// member function member
Delegates cannot be initialized with static member functions
or non-member functions.
Delegates are called analogously to function pointers:
fp(3); // call func(3)
dg(3); // call o.member(3)
Copyright (c) 1999-2002 by Digital Mars, All Rights Reserved