root/trunk/docsrc/type.dd

Ddoc

$(SPEC_S Types,

$(SECTION2 Basic Data Types,

    $(TABLE2 Basic Data Types,
    $(TR $(TH Keyword) $(TH Description) $(TH Default Initializer (.init))
    )
    $(TR
        $(TD $(TT void))
        $(TD no type)
        $(TD -)
    )
    $(TR
        $(TD $(TT bool))
        $(TD boolean value)
        $(TD false)
    )
    $(TR
        $(TD $(TT byte))
        $(TD signed 8 bits)
        $(TD 0)
    )
    $(TR
        $(TD $(TT ubyte))
        $(TD unsigned 8 bits)
        $(TD 0)
    )
    $(TR
        $(TD $(TT short))
        $(TD signed 16 bits)
        $(TD 0)
    )
    $(TR
        $(TD $(TT ushort))
        $(TD unsigned 16 bits)
        $(TD 0)
    )
    $(TR
        $(TD $(TT int))
        $(TD signed 32 bits)
        $(TD 0)
    )
    $(TR
        $(TD $(TT uint))
        $(TD unsigned 32 bits)
        $(TD 0)
    )
    $(TR
        $(TD $(TT long))
        $(TD signed 64 bits)
        $(TD 0L)
    )
    $(TR
        $(TD $(TT ulong))
        $(TD unsigned 64 bits)
        $(TD 0L)
    )
    $(TR
        $(TD $(TT cent))
        $(TD signed 128 bits (reserved for future use))
        $(TD 0)
    )
    $(TR
        $(TD $(TT ucent))
        $(TD unsigned 128 bits (reserved for future use))
        $(TD 0)
    )
    $(TR
        $(TD $(TT float))
        $(TD 32 bit floating point)
        $(TD float.nan)
    )
    $(TR
        $(TD $(TT double))
        $(TD 64 bit floating point)
        $(TD double.nan)
    )
    $(TR
        $(TD $(TT real))
        $(TD largest hardware implemented floating
        point size ($(B Implementation Note:) 80 bits for x86 CPUs)
        or double size, whichever is larger)
        $(TD real.nan)
    )
    $(TR
        $(TD $(TT ifloat))
        $(TD imaginary float)
        $(TD float.nan * 1.0i)
    )
    $(TR
        $(TD $(TT idouble))
        $(TD imaginary double)
        $(TD double.nan * 1.0i)
    )
    $(TR
        $(TD $(TT ireal))
        $(TD imaginary real)
        $(TD real.nan * 1.0i)
    )
    $(TR
        $(TD $(TT cfloat))
        $(TD a complex number of two float values)
        $(TD float.nan + float.nan * 1.0i)
    )
    $(TR
        $(TD $(TT cdouble))
        $(TD complex double)
        $(TD double.nan + double.nan * 1.0i)
    )
    $(TR
        $(TD $(TT creal))
        $(TD complex real)
        $(TD real.nan + real.nan * 1.0i)
    )
    $(TR
        $(TD $(TT char))
        $(TD unsigned 8 bit UTF-8)
        $(TD 0xFF)
    )
    $(TR
        $(TD $(TT wchar))
        $(TD unsigned 16 bit UTF-16)
        $(TD 0xFFFF)
    )
    $(TR
        $(TD $(TT dchar))
        $(TD unsigned 32 bit UTF-32)
        $(TD 0x0000FFFF)
    )
    )
)


$(SECTION2 Derived Data Types,

    $(UL 
    $(LI pointer)
    $(LI array)
    $(LI associative array)
    $(LI function)
    $(LI delegate)
    )

    $(P $(LINK2 arrays.html#strings, $(I Strings)) are a special case of arrays.)
)

$(SECTION2 User Defined Types,

    $(UL 
    $(LI alias)
    $(LI enum)
    $(LI struct)
    $(LI union)
    $(LI class)
    $(V1 $(LI typedef))
    )
)


$(SECTION2 Base Types,

    $(P The $(I base type) of an enum is the type it is based on:)

---
enum E : T { ... }  // T is the $(I base type) of E
---

$(V1
    $(P The $(I base type) of a typedef is the type it is formed from:)

---
typedef T U;        // T is the $(I base type) of U
---
)
)


$(SECTION2 Pointer Conversions,

    $(P Casting pointers to non-pointers and vice versa is allowed in D,
    however, do not do this for any pointers that point to data
    allocated by the garbage collector.
    )
)

$(SECTION2 Implicit Conversions,

    $(P Implicit conversions are used to automatically convert
    types as required.
    )

    $(P A $(V1 typedef or) enum can be implicitly converted to its base
    type, but going the other way requires an explicit
    conversion.
    A literal can be implicitly converted to a typedef.
    For example:
    )

-------------------
$(V1 typedef int myint;
int i;
myint m;
i = m;          // OK
m = i;          // error
m = cast(myint)i;   // OK
m = 3;                  // OK
)
enum Foo { E }
Foo f;
i = f;          // OK
f = i;          // error
f = cast(Foo)i;     // OK
f = 0;                  // error
f = E;                  // OK
-------------------
)


$(SECTION2 Integer Promotions,

    $(P Integer Promotions are conversions of the following types:
    )

    $(TABLE2 Integer Promotions,
    $(TR 
    $(TH from)
    $(TH to)
    )
    $(TR 
    $(TD bool)
    $(TD int)
    )
    $(TR 
    $(TD byte)
    $(TD int)
    )
    $(TR 
    $(TD ubyte)
    $(TD int)
    )
    $(TR 
    $(TD short)
    $(TD int)
    )
    $(TR 
    $(TD ushort)
    $(TD int)
    )
    $(TR 
    $(TD char)
    $(TD int)
    )
    $(TR 
    $(TD wchar)
    $(TD int)
    )
    $(TR 
    $(TD dchar)
    $(TD uint)
    )
    )

    $(P If a $(V1 typedef or) enum has as a base type one of the types
    in the left column, it is converted to the type in the right
    column.
    )
)


$(SECTION2 Usual Arithmetic Conversions,

    $(P 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, looking at the base type:
    )

    $(OL
    $(LI If either operand is real, the other operand is
    converted to real.)

    $(LI Else if either operand is double, the other operand is
    converted to double.)

    $(LI Else if either operand is float, the other operand is
    converted to float.)

    $(LI Else the integer promotions are done on each operand,
    followed by:

    $(OL 
        $(LI If both are the same type, no more conversions are done.)

        $(LI If both are signed or both are unsigned, the
        smaller type is converted to the larger.)

        $(LI If the signed type is larger than the unsigned
        type, the unsigned type is converted to the signed type.)

        $(LI The signed type is converted to the unsigned type.)
    )
    )
    )

    $(P If one or both of the operand types is an enum $(V1 or typedef) after
    undergoing the above conversions, the result type is:)

    $(OL
    $(LI If the operands are the same type, the result will be the
    that type.)
    $(LI If one operand is an enum $(V1 or typedef) and the other is the base type
    of that $(V1 typedef or) enum, the result is the base type.)
    $(LI If the two operands are different $(V1 typedefs or) enums,
    the result is the closest base type common to both. A base type being closer
    means there is a shorter sequence of conversions to base type to get there from the
    original type.)
    )

    $(P Integer values cannot be implicitly converted to another
    type that cannot represent the integer bit pattern after integral
    promotion. For example:)

---
ubyte  u1 = cast(byte)-1;   // error, -1 cannot be represented in a ubyte
ushort u2 = cast(short)-1;  // error, -1 cannot be represented in a ushort
uint   u3 = cast(int)-1;    // ok, -1 can be represented in a uint
ulong  u4 = cast(ulong)-1;  // ok, -1 can be represented in a ulong
---

    $(P Floating point types cannot be implicitly converted to
    integral types.
    )

    $(P Complex floating point types cannot be implicitly converted
    to non-complex floating point types.
    )

    $(P Imaginary floating point types cannot be implicitly converted to
    float, double, or real types. Float, double, or real types
    cannot be implicitly converted to imaginary floating
    point types.
    )
)


$(SECTION2 bool,

    $(P The bool type is a 1 byte size type that can only hold the
    value $(D_KEYWORD true) or $(D_KEYWORD false).
    The only operators that can accept operands of type bool are:
    & | ^ &= |= ^= ! && || ?:.
    A bool value can be implicitly converted to any integral type,
    with $(D_KEYWORD false) becoming 0 and $(D_KEYWORD true) becoming 1.
    The numeric literals 0 and 1 can be implicitly
    converted to the bool values $(D_KEYWORD false) and $(D_KEYWORD true),
    respectively.
    Casting an expression to bool means testing for 0 or !=0 for
    arithmetic types, and $(D_KEYWORD null) or !=$(D_KEYWORD null)
    for pointers or references.
    )
)


$(SECTION2 <a name="delegates">Delegates</a>,

    $(P There are no pointers-to-members in D, but a more useful
    concept called $(I delegates) are supported.
    Delegates are an aggregate of two pieces of data: an
    object reference and a function pointer. The object reference
    forms the $(I this) pointer when the function is called.
    )

    $(P Delegates are declared similarly to function pointers,
    except that the keyword $(B 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
-------------------

    $(P The C style syntax for declaring pointers to functions is
    also supported:
    )

-------------------
int (*fp)(int);     // fp is pointer to a function
-------------------

    $(P 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 $(I o) and
            // member function $(I member)
-------------------

    $(P Delegates cannot be initialized with static member functions
    or non-member functions.
    )

    $(P Delegates are called analogously to function pointers:
    )

-------------------
fp(3);      // call func(3)
dg(3);      // call o.member(3)
-------------------
)

)

Macros:
    TITLE=Types
    WIKI=Type