D (lenguaje de programación)

La programación orientada a objetos está basada en herencia simple, con todas las clases derivadas de la clase Object. D no soporta herencia múltiple; en vez de eso, usa interfaces parecidas a las de Java, que son comparables a las clases abstractas de C++.

La Metaprogramación está soportada por una combinación de plantillas, la ejecución de funciones en tiempo de compilación, tuplas y 'mixins' de cadenas. Soporta CTFE (evaluación de funciones en tiempo de compilación). Los siguientes ejemplos demuestran algunas de las características en tiempo de ejecución del lenguaje D.

Las plantillas en D se pueden escribir en más de un estilo imperativo comparado con el estilo funcional de las plantillas de C++. El siguiente ejemplo es una función regular que calcula el producto factorial de un número:

ulong factorial(ulong n)
{
    ulong Producto = 1;
    for(ulong i = 2; i <= n; i++){
        Producto *= i;
    }
    return Producto;
}

Aquí, se muestra el uso de la palabra reservada static for (la construcción iterativa en tiempo de ejecución en D), para construir una plantilla que es capaz de realizar el mismo cálculo:

template Factorial(ulong n)
{
    ulong Producto = 1;
    static for(i = 2; i <= n; i++){
        Producto *= i;
    }
    return Producto;
}

En los siguientes dos ejemplos, la plantilla y la función definidas arriba se utilizan para calcular factoriales. No es necesario especificar explícitamente los tipos de las constantes cuando el compilador infiere sus tipos desde el lado derecho de las asignaciónes:

enum fact_7 = Factorial!(7);

Este es un ejemplo de una función en tiempo de ejecución. Las funciones ordinarias pueden usar constantes, aunque expresiones en tiempo de ejecución deben reunir ciertos criterios:

enum fact_9 = factorial(9);

La función std.string.format, del estilo printf, sirve para dar formato a los datos (también en tiempo de ejecución, a través de CTFE (ejecución de función en tiempo de ejecución), y el pragma "msg" (directiva) que muestra el resultado en tiempo de ejecución:

import std.string : format;
pragma(msg, format("7! = %s", fact_7));
pragma(msg, format("9! = %s", fact_9));

Los "mixins" de cadenas, combinadas con las CTFE, permiten generar código D usando operaciones expresadas en cadenas de caracteres, en tiempo de ejecución. Puede ser utilizado para análisis sintáctico de un lenguaje específico del dominio hacia código D, el cual se compila como parte del programa:

import FooToD; // Modulo hipotetico que contiene una funcion que analiza el código fuente Foo
               // y devuelve el código D equivalente
void main()
{
    mixin(fooToD(import("example.foo")));
}

D soporta características de programación funcional tal como funciones anónimas, clausuras, objetos recursivamente immutables y el uso de funciones de orden superior. Hay dos sintaxis para funciones anónimas, incluyendo una forma de declaración múltiple y una notación abreviada de expresiones simples:[6]

int function(int) g;
g = (x) { return x * x; }; // forma larga
g = (x) => x * x; // forma abreviada

La memoria es usualmente manejada por un recolector de basura, pero objetos específicos pueden ser finalizados inmediatamente cuando salen del ámbito. Es posible el manejo de memoria explícito usando los operadores sobrecargados new y delete, y simplemente llamando las funciones malloc y free de C directamente. La recolección de basura puede ser controlada: los programadores pueden agregar y excluir rangos de memoria de ser observados por el recolector, pueden pausar y reanudar el recolector y forzar un ciclo generacional o de recolección completa.[7] El manual da muchos ejemplos de cómo implementar diferentes esquemas de manejo de memoria altamente optimizados para cuando la recolección de basura es inadecuada para el programa.

La API de C es admitida, al igual que todos los tipos fundamentales y derivados de C, permitiendo acceso directo al código existente escrito en C y bibliotecas. La biblioteca estándar de C es parte del D estándar. A menos que se usen namespaces muy explícitos puede ser de alguna forma difícil de acceder, como se puede observar en módulos escritos en D que hagan uso de dicha característica. Pero la biblioteca estándar de D es usualmente suficiente.

Este programa imprime sus argumentos de la línea de comandos. La función principal main es el punto de inicio de un programa en D, y args es un arreglo de cadena de caracteres que representa los argumentos de línea de comandos. En D, string es un arreglo de caracteres, que se representa con char[] en D1, o immutable(char)[] en D2.

import std.stdio: writefln;

void main(string[] args)
{
    efln("args[%d] = '%s'", i, arg);
}

La palabra reservada foreach puede iterar cualquier colección. En este caso, produce una sucesión de índices (i) y valores (arg) desde el arreglo args. El índice i y el valor arg tiene sus tipos inferidos desde del tipo del arreglo args.

La sobrecarga de operadores en D a veces son menos poderosas que las de C++. Un ejemplo es el opIndex, que sufre porque D no permite regresar referencias. Esto hace operaciones como obj[i]++; imposibles. La solución parcial de D es el operador opIndexAssign, que solo repara casos donde la expresión indexeada es solo un valor L como obj[i] = 5 pero no los casos originales.

La biblioteca estándar en D es llamada Phobos. Algunos miembros de la comunidad piensan que Phobos es demasiado simple y que posee numerosos problemas, por lo cual un reemplazo llamado Tango fue escrito.[8] Sin embargo, Tango y Phobos eran incompatibles debido a varias diferencias (soporte de hilos, recolector de basura, etc). La existencia de dos bibliotecas, ambas de uso elevado, llevó a problemas significativos donde algunos paquetes usan Phobos y otros usan Tango. Este problema fue resuelto con la versión 2.0 del lenguaje.

Bibliotecas compartidas ELF de Unix son soportadas hasta un punto usando el compilador GDC. En Windows, DLLs son soportadas y permiten a objetos recolectados por el recolector de basura de ser seguramente pasados a funciones de C, ya que el recolector de basura revisa el stack por punteros. Sin embargo, todavía hay limitaciones con DLLs en D incluyendo el hecho de que la información en tiempo de ejecución de clases definidas en la DLL es incompatible con esas definidas en el ejecutable, y que cualquier objeto creado desde la DLL debe ser finalizado antes de que la DLL sea descargada.[9]