[z.facultad/75.31/presentacion.git] / presentacion_d.lyx

#LyX 1.3 created this file. For more info see http://www.lyx.org/
\lyxformat 221
\textclass article
\language spanish
\inputencoding latin1
\fontscheme palatino
\graphics default
\paperfontsize default
\spacing single 
\papersize a4paper
\paperpackage widemarginsa4
\use_geometry 0
\use_amsmath 0
\use_natbib 0
\use_numerical_citations 0
\paperorientation portrait
\secnumdepth 3
\tocdepth 3
\paragraph_separation indent
\defskip medskip
\quotes_language english
\quotes_times 2
\papercolumns 1
\papersides 1
\paperpagestyle default

\layout Title

Teoría de Lenguaje
\newline 
Lenguaje D
\layout Author

Leandro Lucarella (77891)
\layout Date

30 de Mayo de 2005
\layout Section

Introducción
\layout Standard

El lenguaje de programación D fue concebido en el año 1999 como una reingeniería
 de C y C++, que apunta a un lenguaje compilado de alto rendimiento pero
 con un nivel un poco más alto que C o C++.
 D pretende ser compatible con C (al menos a nivel de código objeto), pero
 
\series bold 
no
\series default 
 con C++.
\layout Standard

Una de las cosas más importantes que elimina D es el preprocesador de C,
 poniendo la funcionalidad necesaria directamente en el compilador (incluyendo
 manejo de módulos, compilación condicional, etc.).
\layout Standard

El lenguaje sigue, al día de hoy, sin estar completamente definido y con
 algunas cosas sin implementar.
\layout Section

Sistema de tipos
\layout Subsection

Tipos básicos
\layout Standard

D tiene una gran variedad de tipos básicos, ya que, además de poseer todos
 los tipos básicos para poder desarrollar a bajo nivel como en C, dispone
 de números complejos y otros tipos no tan comunes.
\layout Standard

Entre los tipos compatibles con C se encuentra:
\layout Description

Vacío 
\family typewriter 
void
\layout Description

Signados 
\family typewriter 
char wchar byte short int long
\layout Description

No\SpecialChar ~
signados 
\family typewriter 
char wchar ubyte ushort uint ulong
\layout Description

Punto\SpecialChar ~
flotante 
\family typewriter 
float double
\layout Standard


\family typewriter 
char
\family default 
 y 
\family typewriter 
wchar
\family default 
 no tienen su contraparte signada, ya que son para uso explícito de variables
 de caracter (UTF-8 y UTF-16 respectivamente).
 Además agrega algunos nuevos tipos: 
\family typewriter 
bit
\family default 
 (análogo a 
\family typewriter 
bool
\family default 
 de C++), 
\family typewriter 
cent
\family default 
 y 
\family typewriter 
ucent
\family default 
 (128 bits, reservado para uso futuro); 
\family typewriter 
real
\family default 
 (tipo de punto flotante más grande representable por la arquitectura, en
 Intel es de 80 bits) y 
\family typewriter 
dchar
\family default 
 (UTF-32).
\layout Standard

Finalmente agrega el tipo básico imaginario, cuyos tipos son iguales que
 los 
\emph on 
racionales
\emph default 
 (de punto flotante) pero anteponiendo una 
\family typewriter 
i
\family default 
: 
\family typewriter 
ifloat idouble ireal
\family default 
.
 Combinando 
\emph on 
racionales
\emph default 
 con imaginarios se pueden forma complejos, cuyos variaciones son de la
 misma forma, sólo que se antepone una 
\family typewriter 
c
\family default 
 en vez de una 
\family typewriter 
i
\family default 
:
\family typewriter 
 cfloat cdouble creal
\family default 
.
\layout Subsection

Tipos derivados
\layout Standard

De los tipos básicos pueden derivarse otros tipos.
 Esto tipos son punteros, array y funciones, siendo estas últimas tal vez
 un caso muy particular.
 Los array tal vez podrían considerarse tipos compuestos, pero como la variable
 en sí es un puntero, en realidad no lo es.
 Es decir, para obtener un elemento del array hay que aplicar aritmética
 de punteros, ya sea 
\emph on 
explícitamente
\emph default 
 o 
\emph on 
implícitamente
\emph default 
 utilizando el operador corchetes.
\layout Subsection

Tipos de usuario
\layout Standard

D dispone de varias formas de definir tipos de usuario, entre ellos varios
 que provienen de C.
 Veamos cada uno.
\layout Subsubsection

alias
\layout Standard

Un alias es la forma más primitiva de tipo de usuario, simplemente es otra
 forma de escribir un tipo ya definido (es análogo al typedef de C).
 Ejemplo:
\layout LyX-Code

alias int tipo;
\layout LyX-Code

int i = 1;
\layout LyX-Code

tipo t = i; // Correcto (semánticamente son los dos int)
\layout Standard

A partir de ahora puedo hacer referencia a 
\family typewriter 
int
\family default 
 llamándolo 
\family typewriter 
tipo
\family default 
.
 Es decir, son semánticamente idénticos.
\layout Subsubsection

typedef
\layout Standard

typedef es similar al alias, con la salvedad de que define un tipo semánticament
e distinto (por más que la estructura en memoria y la forma de manejarlo
 sea idéntica).
 Como concecuencia de esto, se efectua chequeo de tipos y, por ejemplo,
 no puedo asignar a una variable de un tipo que es un typedef de otro:
\layout LyX-Code

typedef int tipo;
\layout LyX-Code

int i = 1;
\layout LyX-Code

// No compila porque se está asignando un int a un tipo
\layout LyX-Code

// tipo t = i;
\layout LyX-Code

tipo t = cast(tipo)(i); // Correcto (conversión explícita)
\layout Subsubsection

enum
\layout Standard

Enum es en realidad un 
\family typewriter 
int
\family default 
 que puede tener sólo un número predefinido de valores, que además son represent
ados simbólicamente.
\layout LyX-Code

enum Dias { DOMINGO, LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO }
\layout LyX-Code

Dias d = Dias.MARTES;
\layout Subsubsection

union
\layout Standard

Union es otro tipo de dato definido por el usuario proveniente de C, que
 permite ver una misma 
\emph on 
celda
\emph default 
 de memoria de distintas formas.
\layout LyX-Code

union Celda
\layout LyX-Code

{
\layout LyX-Code

    int i;
\layout LyX-Code

    real r;
\layout LyX-Code

}
\layout LyX-Code

Celda c;
\layout LyX-Code

c.i = 1;
\layout LyX-Code

c.r += 2.5;
\layout Standard

Tanto 
\family typewriter 
r
\family default 
 como 
\family typewriter 
i
\family default 
 se guarda en la misma celda de memoria, por lo que se utilizan como mecanismos
 alternativos para operar en ella, usando semántica de uno u otro tipo.
 Esto es particularmente útil para aplicaciones de bajo nivel, donde el
 espacio en memoria es muy reducido.
 Esta técnica permite tener una variable cuyo tipo es, en cierto modo, variable.
\layout Subsubsection

struct
\layout Standard

El struct es muy similar al de C, con algunos agregados, como la posibilidad
 de tener funciones miembro, inicializadores, etc.
 No es más que el agrupamiento de un conjunto de variables, a las que se
 accede a través de un identificador:
\layout LyX-Code

struct Fecha
\layout LyX-Code

{ 
\layout LyX-Code

    uint dia = 1;
\layout LyX-Code

    uint mes = 1;
\layout LyX-Code

    uint anio = 2005;
\layout LyX-Code

    void print()
\layout LyX-Code

    {
\layout LyX-Code

        printf("dia: %d, mes: %d, anio: %d
\backslash 
n", dia, mes, anio);
\layout LyX-Code

    }
\layout LyX-Code

}
\layout LyX-Code

Fecha f;
\layout LyX-Code

f.dia = 30;
\layout LyX-Code

f.mes = 5;
\layout LyX-Code

f.print();
\layout Subsubsection

class
\layout Standard

Las clases son la forma en la que D implementa la orientación a objetos,
 que veremos en detalle más adelante.
 Por ahora sólo adelantaremos que es muy similar a un struct, sólo que guarda
 algo más de información de control (como la tabla virtual) para poder implement
ar polimorfismo y herencia.
\layout Section

Expresiones
\layout Subsection

Operaciones
\layout Standard

D provee operaciones las operaciones básicas que provee prácticamente cualquier
 lenguaje: asignación, comparación, incremento, decremento, suma, resta,
 multiplicación, división, resto, algebra booleana (and, or, xor, not),
 shifting.
 También provee llamadas a funciones.
 Los procedimientos son un caso particular de funciones que no devuelven
 nada (void).
\layout Standard

Además de esto, provee operaciones propias de un lenguaje imperativo de
 bajo nivel: aritmética de punteros, operador [] como método alternativo
 para acceder a una posición de un array, desreferenciamiento, obtención
 de una dirección de memoria de una variable, etc.
 También incluye un operador para comparar si 2 referencias referencian
 al mismo objeto y algunas operaciones propias de los arrays, como para
 saber si un elemento está dentro del array o concatenación de arrays y
 slicing.
\layout Standard

Finalmente provee un operador de resolución de scope, para acceder a variables
 definidas dentro de tipos compuestos (como estructuras o uniones) o módulos.
\layout Subsection

Variables
\layout Comment

Si hay o no variables sin nombre
\layout Standard

El lenguaje cuenta con tipado débil, con conversiones implícitas, por ejemplo,
 entre punteros.
\layout Subsection

Representación de la memoria
\layout Standard

La representación en memoria es muy similar a cualquier lenguaje imperativo
 compilado, como C o C++.
 Cada tipo de variable ocupa una cierta cantidad de bytes y se almacenan
 en memoria de forma contigua (al menos lógicamente), según la alineación
 de la arquitectura para la que fue compilado.
 Esto trae el clásico problema de los 
\emph on 
huecos
\emph default 
 que pueden quedar, para que cada variable ocupe un múltiplo de palabras
 de la arquitectura, para manejarla con mayor eficiencia, por lo que el
 compilador provee formas de especificar la alineación a usar.
\layout Standard

Las variables globales (que incluye a las estáticas) se almacenan en tiempo
 de compilación (estáticamente) dentro del código del programa, en el área
 de datos.
 Las variables locales a las funciones se almacenan en una pila de ejecución,
 por lo tanto debe tener una pila por cada hilo de ejecución.
 Por último hay un área de memoria 
\emph on 
libre
\emph default 
 que se le pide al sistema operativo a medida que se nececesita (heap).
 Una particularidad extra de D es que los tipos definidos por el usuario
 de tipo 
\series bold 
class
\series default 
, se almacenan en el heap.
 En el stack y en el área de datos del programa sólo pueden guardarse referencia
s (punteros) a instancias de una clase (en realidad hay excepciones, ya
 que se puede pedir memoria del stack 
\emph on 
a mano
\emph default 
 e inicializar el objeto en esa memoria, pero no es el caso general).
\layout Subsection

Modelo de ejecución
\layout Standard

D es un lenguaje imperativo compilado, por lo que d
\layout Subsection

Punteros
\layout Subsection

Recolección de basura
\layout Subsection

Instrucciones
\layout Subsection

Rutinas
\layout Subsubsection

Pasaje de parámetros
\layout Standard

Por copia en demanda (copy on write) y objetos por referencia.
\layout Subsubsection

Anidamiento
\layout Section

Estructura del programa
\layout Subsection

Módulos, espacios de nombres, Interfaces
\layout Section

Orientación a objetos
\layout Subsection

TAD's
\layout Subsection

Polimorfismo
\layout Comment

Si hay orientación a objetos y describir cómo es.
\layout Section

Paralelismo / Concurrencia
\layout Section

¿Para qué no sirve este lenguaje?
\layout Section

¿Para qué sí sirve este lenguaje? 
\the_end