D (linguaggio di programmazione)

Da Wikipedia, l'enciclopedia libera.

Il linguaggio di programmazione D nasce nel dicembre 1999 dalla mente di Walter Bright.

È un linguaggio orientato agli oggetti, e potrebbe definirsi un'evoluzione del linguaggio C e C++. Fra le caratteristiche si annoverano: gestione più semplice delle classi e dei template rispetto al C++, un garbage collector come in Java, supporto a RTTI (Runtime type information), introduzione del tipo intero a 128 bit, package in stile Java al posto dei file header, chiamata alle API di Windows, chiamata alle funzioni scritte in C (usando la parola chiave extern), array associativi (oltre ai classici in stile puntatore, statici, dinamici), e poi molte altre cose.

Al momento è possibile utilizzarlo per i sistemi Windows, Linux x86 e PPC, Mac OS X, AIX e FreeBSD tramite un frontend del compilatore GCC chiamato GDC.

[modifica] Origine del nome e storia

Il D è un linguaggio di programmazione ideato dalla DigitalMars, il suo obiettivo è raggiungere la potenza e le alte prestazioni dei linguaggi di medio livello come C e C++ ma con la grande produttività e semplice portabilità di linguaggi di alto livello come C#, Java, Python, Ruby e simili. In particolare la sintassi e le caratteristiche tecniche del compilatore riprendono C/C++, C# e Java.

[modifica] Features del compilatore

Il compilatore D è strutturato in modo diverso rispetto ai linguaggi principali, ereditando punti di forza creando un linguaggio estremamente originale. Tra le piu' importanti caratteristiche, ricordiamo

Veloce nella compilazione, più di quello Java e C++

Utilizzo della garabage collection simile a .net e java, ma a quanto pare più veloce

Si basa su una libreria detta PHOBOS ben fatta(supporta sockets, thread, zip, base64, funzioni linux, funzioni windows,md5 e altro),inoltre supporta la libreria C direttamente.

Il compilatore riconosce l'html presente nel codice sorgente ignorandolo e permettendo comunque la compilazione (molto utile per documentare un programma)

Nonostante le somiglianze con C# e Java non necessita di installare separatamente degli interpreti, tutto il necessario sta nel binario senza che assuma dimensioni spropositate.

C'è un compilatore per win32 e linux su x86, ma su sourgeforge c'è un progetto detto GDC; che supporta anche altri OS

Il codice supporta i codici stile sh, quindi i file sorgenti possono cominciare su unix con #! /usr/bin/dmd -run per esempio

[modifica] Caratteristiche del D

Il D ha una serie di funzioni uniche che nessun linguaggio di programmazione, per ora, possiede. Ne saranno qui elencate le principali.

[modifica] Nested Functions

Con questa caratteristica una funzione può contenere a sua volta delle dichiarazioni di altre funzioni, rispettando comunque le regole generali dello scope per il loro uso. Ecco un esempio pratico.

void foo()
{
  void A()
  {
    B();   // ok
    C();   // error, C undefined
  }
  void B()
  {
      void C()
      {
          void D()
          {
              A();      // ok
              B();      // ok
              C();      // ok
              D();      // ok
          }
      }
  }
  A(); // ok
  B(); // ok
  C(); // error, C undefined
}

Potete notare che la funzione più interna ha accesso a tutte quelle esterne, ma una funzione esterna non può accedere alle funzioni interne di una sua funzione interna, una sorta di pseudo incapsulamento ma senza classi. Caratteristica importante è che l'ordine delle funzioni è fondamentale. Ecco un'altro esempio

void test()
{
   void foo() { bar(); }    // error, bar not defined
   void bar() { foo(); }    // ok
}

Si può notare di come la reciproca chiamata di funzione non è possibile, in quanto nella compilazione di foo() la funzione bar non è stata ancora definita.La soluzione in D è usare i delegate, che sono supportati:

void test()
{
   void delegate() fp;
   void foo() { fp(); }
   void bar() { foo(); }
   fp = &bar;
}

Ci sono dicerie secondo le quali la DigitalMars rimuoverà questa limitazioe a breve.

Un'altra caratteristica è che una funzione nested può accedere ai campi di quella esterna, se la funzione è static anche il campo deve essere static.

Se dentro la funzione creiamo una che contiene una funzione con un'altra dentro, queste funzioni potranno accedere solo ai campi static.

void test()
{   int j;
   static int s;

   struct Foo
   {   int a;

   int bar()
   {   int c = s;        // ok, s is static
       int d = j;        // error, no access to frame of test()

       int foo()
       {
       int e = s;    // ok, s is static
       int f = j;    // error, no access to frame of test()
       return c + a;    // ok, frame of bar() is accessible,
               // so are members of Foo accessible via
               // the 'this' pointer to Foo.bar()
       }
   }
   }
}

[modifica] Funzioni literals

Questo permette di creare un puntatore a funzione o un delegato direttamente in un'espressione, quindi invece di fare così:

int function(char c) fp;    // dichiara un puntatore a funzione

void test()
{
   static int foo(char c) { return 6; }

   fp = &foo;
}

si può fare così:

int function(char c) fp;

void test()
{
   fp = function int(char c) { return 6;} ;
}

Questo vale anche per i delegate, quindi si può utilizzare questo codice:

double test()
{   double d = 7.6;
   float f = 2.3;

   void loop(int k, int j, void delegate() statement)
   {
   for (int i = k; i < j; i++)
   {
       statement();
   }
   }

   loop(5, 100, delegate { d += 1; } );
   loop(3, 10,  delegate { f += 1; } );

   return d + f;
}

[modifica] Array ridimensionabili

Gli array sono implementati con nuove funzionalità rispetto a quelli in stile C e C++ (in C++ sono comunque disponibili funzionalità analoghe utilizzando i container della STL). Tramite il campo length è possibile accedere alla dimensione di un array e ridimensionarlo, senza ricorrere all'allocazione dinamica come new, malloc e realloc.

int[] array;
while (1)
{   c = getinput();
   if (!c)
      break;
   array.length = array.length + 1;
   array[array.length - 1] = c;
}

[modifica] Slicing

Permette di creare un nuovo riferimento a un subarray. La sintassi per il suo uso è:

int[10] a;    // declare array of 10 ints
int[] b;

b = a[1..3];    // a[1..3] is a 2 element array consisting of
       // a[1] and a[2]
foo(b[1]);    // equivalent to foo(0)
a[2] = 3;
foo(b[1]);    // equivalent to foo(3)

[modifica] Array associativi

Permette di associare il valore di un elemento di un array ad un altro tipo di dato, diverso dal classico intero, quindi potremo avere:

int[char[]] b;        // associative array b of ints that are
           // indexed by an array of characters.
           // The KeyType is char[]
b["hello"] = 3;        // set value associated with key "hello" to 3
func(b["hello"]);    // pass 3 as parameter to func()
...
int* p;
p = ("hello" in b);
if (p != null)
printf(*p);
b.remove("hello");
...

[modifica] Strong typedefs

Consideriamo il seguente typedef:

typedef int myint;

E' possibile dichiarare una funzione che accetta int come argomento e poi passargli un myint senza che il compilatore generi un errore: ossia il compilatore è in grado di risolvere i riferimenti typedef in tipi di dato fondamentali.

E' anche possibile creare dei typedef con valori visualizzati costanti.

typedef int myint = 9718;
myint i; //inizializzato a 9718

Se invece si vuole che se una funzione accetti solo e sempre un int, e che quindi i typedef debbano essere considerati come tipi di dati diversi, si può utilizzare, al posto di typedef, l'istruzione alias. Ad esempio:

alias int myint;

Farà in modo che utilizzando myint in una funzione che accetta un int dia un errore di compilazione.

[modifica] Mixin

Il Mixin permette di ottenere un set di dichiarazioni da un template specificato e conservarle da un'altra parte.

template Foo()
{
   int x = 5;
}

mixin Foo;

struct Bar
{
   mixin Foo;
}

void test()
{
   printf("x = %d\n", x);        // prints 5
   {   Bar b;
   int x = 3;

   printf("b.x = %d\n", b.x);    // prints 5
   printf("x = %d\n", x);        // prints 3
   {
       mixin Foo;
       printf("x = %d\n", x);    // prints 5
       x = 4;
       printf("x = %d\n", x);    // prints 4
   }
   printf("x = %d\n", x);        // prints 3
   }
   printf("x = %d\n", x);        // prints 5
}

Questo vale anche per le funzioni:

template Foo()
{
   void func() { printf("Foo.func()\n"); }
}

class Bar
{
   mixin Foo;
}

class Code : Bar
{
   void func() { printf("Code.func()\n"); }
}

void test()
{
   Bar b = new Bar();
   b.func();        // calls Foo.func()

   b = new Code();
   b.func();        // calls Code.func()
}

posso specificare il tipo del template

template Foo(T)
{
   T x = 5;
}

mixin Foo!(int);        // create x of type int

ed ecco un esempio finale

template duffs_device(alias id1, alias id2, alias s)
{
   void duff_loop()
   {
   if (id1 < id2)
   {
       typeof(id1) n = (id2 - id1 + 7) / 8;
       switch ((id2 - id1) % 8)
       {
       case 0:        do {  s();
       case 7:              s();
       case 6:              s();
       case 5:              s();
       case 4:              s();
       case 3:              s();
       case 2:              s();
       case 1:              s();
                 } while (--n > 0);
       }
   }
   }
}

void foo() { printf("foo\n"); }

void test()
{
   int i = 1;
   int j = 11;

   mixin duffs_device!(i, j, delegate { foo(); } );
   duff_loop();    // executes foo() 10 times
}

[modifica] Static If Condition

Lo static if condition è stato progettato appositamente per sostituire le direttive preprocessore. Questa istruzione valuta un'espressione in compile time. Ecco un esempio:

const int i = 3;
int j = 4;

static if (i == 3)    // ok, at module scope
   int x;

class C
{   const int k = 5;

   static if (i == 3)    // ok
   int x;
   else
   long x;

   static if (j == 3)    // error, j is not a constant
   int y;

   static if (k == 5)    // ok, k is in current scope
   int z;
}

template INT(int i)
{
   static if (i == 32)
   alias int INT;
   else static if (i == 16)
   alias short INT;
   else
   static assert(0);    // not supported
}

INT!(32) a;    // a is an int
INT!(16) b;    // b is a short
INT!(17) c;    // error, static assert trips

Di conseguenza, esiste anche un'assert statico

[modifica] Identity Expressions

Permette di controllare le identità di due variabili con l'operatore is o !is(l'opposto). Quindi controlla, ad esempio per le classi, se sono la stessa istanza, per gli array se contengono gli stessi elementi ecc.... Utilizzato prevalentemente per il controllo di omogeneità di 2 oggetti.

[modifica] Implicit Type Inference

Usando auto può essere reso implicito, in un'assegnazione, un tipo di variabile.

static x = 3;       // x is type int
auto y = 4u;       // y is type uint
auto s = "string"; // s is type char[6]

class C { ... }

auto c = new C();  // c is a handle to an instance of class C

[modifica] Contract Programming

La programmazione per contratto è ottima per evitare bugs. Viene contrallata una condizione in entrata alla funzione e in uscita, quindi si controlla un requisito per eseguire il corpo, e si ritorna il risultato solo se la condizione è vera. E' anche presente nel linguaggio Eiffel

long square_root(long x)
   in
   {
   assert(x >= 0);
   }
   out (result)
   {
   assert((result * result) == x);
   }
   body
   {
   return math.sqrt(x);
   }

[modifica] Unit test

L'utilty unit test serve per fare test al volo di una classe. Infatti evita di dover, per fare il test di una classe, creare un file sorgente con in main(), istanziare la classe, utilizzarla... E' possibile, in D, procedere in questo modo

class Sum
{
   int add(int x, int y) { return x + y; }

   unittest
   {
   Sum sum = new Sum;
   assert(sum.add(3,4) == 7);
   assert(sum.add(-2,0) == -2);
   }
}

void main() {
}

Ci si deve però ricordare di dare al compilatore il parametro -unittest

[modifica] Scope Statement

Serve per eseguire una funzione all'uscita di uno scope(indipendentemente dal fatto che ci siano o meno errori),all'uscita con errori, e all'uscita senza errori, ecco un esempio(da notare che vengono eseguiti all'inverso, dal basso verso l'alto):

Un esempio semplice è questo:

writef("1");
{
   writef("2");
   scope(exit) writef("3");
   scope(exit) writef("4");
   writef("5");
}
writefln();

che stampa 4321

Questo è un esempio un pò piu' complesso

class Foo
{
   this() { writef("0"); }
   ~this() { writef("distrutto"); }
}

try
{
   scope(exit) writef("2");
   scope(success) writef("3");
   auto Foo f = new Foo();
   scope(failure) writef("4");
   throw new Exception("msg");
   scope(exit) writef("5");
   scope(success) writef("6");
   scope(failure) writef("7");
}
catch (Exception e)
{
}
writefln();

che stampa 0412

[modifica] Struct member alignment control

Permette di specificare l'allineamento dei membri di una struttura, con una sintassi simile a questa:

align (1) struct S
{   byte a;    // placed at offset 0
   byte[3] filler1;
   byte b;    // placed at offset 4
   byte[3] filler2;
}

[modifica] Collegameni esterni

(EN) Sito del produttore
(EN) gdc, supporto del linguaggio D per il compilatore GCC
(EN) Differenze tra C,C++,Java e D
(EN) Compilatore opensource che supporta vari sistemi operativi
(EN) Sito completamente dedicato al D
(EN) Wiki riguardo al D
(EN) Editor multilinguaggio, utile per il D
(IT) Articolo originale

Principali linguaggi di programmazione (tutti)

Estratto da "http://it.wikipedia.org../../../d/_/%28/D_%28linguaggio_di_programmazione%29.html"

Categoria: Linguaggi di programmazione