From f9bdfd92aa5ded9b0a19df26a04fdac7ad39451a Mon Sep 17 00:00:00 2001 From: Leandro Lucarella Date: Thu, 26 May 2005 00:55:12 +0000 Subject: [PATCH] =?utf8?q?Versi=C3=B3n=20preliminar=20de=20informe=20de=20?= =?utf8?q?TDL.?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit --- ejemplos/align.d | 27 ++ ejemplos/cadena_estatica.d | 20 ++ ejemplos/enum.d | 9 + ejemplos/imaginario.d | 8 + ejemplos/struct.d | 20 ++ presentacion_d.lyx | 516 +++++++++++++++++++++++++++++++++++++ 6 files changed, 600 insertions(+) create mode 100644 ejemplos/align.d create mode 100644 ejemplos/cadena_estatica.d create mode 100644 ejemplos/enum.d create mode 100644 ejemplos/imaginario.d create mode 100644 ejemplos/struct.d create mode 100644 presentacion_d.lyx diff --git a/ejemplos/align.d b/ejemplos/align.d new file mode 100644 index 0000000..6a3447f --- /dev/null +++ b/ejemplos/align.d @@ -0,0 +1,27 @@ + +align (1) byte a, b, c, d; +align (4) byte e, f, g, h; + +struct S +{ + byte a; + byte[3] b; + byte[3] c; + byte d; +} + +align (1) +struct SA +{ + byte a; + byte[3] b; + byte[3] c; + byte d; +} + +S s; +SA sa; +bit z; + +void main() {s.a=1;} + diff --git a/ejemplos/cadena_estatica.d b/ejemplos/cadena_estatica.d new file mode 100644 index 0000000..99cb767 --- /dev/null +++ b/ejemplos/cadena_estatica.d @@ -0,0 +1,20 @@ + +int main(char[][] args) +{ + int i = 0; + void f() + { + printf("f(): %d\n", i); + } + void g() + { + int i = 1; + f(); + printf("g(): %d\n", i); + } + f(); + i = 2; + g(); + return 0; +} + diff --git a/ejemplos/enum.d b/ejemplos/enum.d new file mode 100644 index 0000000..db8a6dd --- /dev/null +++ b/ejemplos/enum.d @@ -0,0 +1,9 @@ + +enum Dias { DOMINGO, LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO } + +void main() +{ + Dias d = Dias.MARTES; + printf("%d\n", cast(int)(d)); +} + diff --git a/ejemplos/imaginario.d b/ejemplos/imaginario.d new file mode 100644 index 0000000..cb33390 --- /dev/null +++ b/ejemplos/imaginario.d @@ -0,0 +1,8 @@ + +void main() +{ + ifloat i = 1.0i; + cfloat z = 3.0 + 1.2i; + printf("i = %i, z = %c\n", i, z); +} + diff --git a/ejemplos/struct.d b/ejemplos/struct.d new file mode 100644 index 0000000..bbf0c38 --- /dev/null +++ b/ejemplos/struct.d @@ -0,0 +1,20 @@ + +struct Fecha +{ + uint dia = 1; + uint mes = 1; + uint anio = 2005; + void print() + { + printf("dia: %d, mes: %d, anio: %d\n", dia, mes, anio); + } +} + +void main() +{ + Fecha f; + f.dia = 30; + f.mes = 5; + f.print(); +} + diff --git a/presentacion_d.lyx b/presentacion_d.lyx new file mode 100644 index 0000000..e59d805 --- /dev/null +++ b/presentacion_d.lyx @@ -0,0 +1,516 @@ +#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 -- 2.43.0