D programming Language

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 ASCII
wchar	unsigned Wide char (Implementation Note: 16 bits on Win32 systems, 32 bits on linux, corresponding to C's wchar_t type)

Derived Data Types

• 
  pointer
  
• 
  array
  
• 
  function
  

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:

1. 
   Typedefs are converted to their underlying type.
   
2. 
   If either operand is extended, the other operand is converted to extended.
   
3. 
   Else if either operand is double, the other operand is converted to double.
   
4. 
   Else if either operand is float, the other operand is converted to float.
   
5. 
   Else the integer promotions are done on each operand, followed by:
   
   1. 
      If both are the same type, no more conversions are done.
      
   2. 
      If both are signed or both are unsigned, the smaller type is converted to the larger.
      
   3. 
      If the signed type is larger than the unsigned type, the unsigned type is converted to the signed type.
      
   4. 
      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)

Directory: upload
upload -> 587 Return function, r i(X) r i(0) r i(1) r i(2) r i(3) 1 0 2 4 6 Thermal Station, I 2 0 1 5 6 3 0 3 5 6 10
upload -> Department of science and humanities department of mathematics part-a questions and answers
upload -> The Case Against the nypd’s Quota-Driven ‘Broken Windows’ Policing What Is It?
upload -> For want of a nail
upload -> Traditional British values
upload -> Tv shows, Made for tv movies, Mini Series & Internet Programs Shot at Paramount Ranch
upload -> Ownership Models There are two different types of ownership models
upload -> Police Militarization
upload -> City of rising star regular meting thursday, july 14, 2016
upload -> Township of winfield

Download 1.66 Mb.

Share with your friends: