+entrando a optimización
+\begin_inset Quotes erd
+\end_inset
+
+);
+\layout LyX-Code
+
+ optimizar();
+\layout LyX-Code
+
+}
+\layout Standard
+
+D además provee varios identificadores de versión predefinidos, como la
+ plataforma,
+\emph on
+endianess
+\emph default
+, sistema operativo, etc.
+\layout Standard
+
+Además provee otros métodos, como
+\family typewriter
+static if
+\family default
+,
+\family typewriter
+static assert
+\family default
+,
+\family typewriter
+iftype
+\family default
+ o
+\family typewriter
+debug
+\family default
+, pero son todas vueltas de tuerca sobre el mismo concepto.
+\layout Subsection
+
+
+\begin_inset LatexCommand \label{sub:Assembly-embebido}
+
+\end_inset
+
+Assembly embebido
+\layout Standard
+
+D, al igual que C, permite embeber assembly en el lenguaje.
+ Esto es útil para hacer código de alta performance para fragmentos críticos,
+ ya que D está pensando como un lenguaje de alta performance y apto para
+ el desarrollo de aplicaciones de sistema (como controladores, etc).
+\layout Section
+
+
+\begin_inset LatexCommand \label{sec:Orientación-a-objetos}
+
+\end_inset
+
+Orientación a objetos
+\layout Standard
+
+Como ya se ha mencionado, D provee orientación a objetos principalmente
+ a través de el tipo class (ver sección
+\begin_inset LatexCommand \vref{sub:tipo-class}
+
+\end_inset
+
+), pero provee algunos mecanismos también a través de los módulos o struct.
+\layout Subsection
+
+Abstracción
+\layout Standard
+
+La abstracción de datos puede darse a nivel de class, struct o module.
+ Ambos proveen mecanismos para poder efectuar operaciones sobre un dato
+ sin conocerlo.
+ En el caso de struct y class es exactamente igual en cuanto a abstracción.
+ El módulo es un poco diferente ya que hay sólo una instancia del mismo
+ (es decir, todos sus datos son estáticos), pero también puede servir para
+ abstraer.
+ D provee sintaxis acoplada (
+\emph on
+bundle
+\emph default
+) a través del operador de
+\emph on
+scope
+\emph default
+
+\begin_inset Quotes eld
+\end_inset
+
+.
+\begin_inset Quotes erd
+\end_inset
+
+, que se utiliza tanto para class como para struct y module.
+ El module, al no ser un tipo en sí, no soporta sintaxis desacoplada (
+\emph on
+unbundle
+\emph default
+).
+ Lo mismo pasa con los métodos estáticos de clase.
+\layout Standard
+
+Todos los objetos en D son con estado explícito, aunque pueden
+\emph on
+emularse
+\emph default
+ objetos
+\emph on
+inmutables
+\emph default
+ declarándolos
+\family typewriter
+const
+\family default
+, pero esto no hace se se resuelvan en tiempo de compilación, en realidad
+ tienen estado sólo que el compilador no deja que se modifique.
+ Es decir, no hay forma de tener abstracción declarativa.
+\layout Subsubsection
+
+Propiedades
+\layout Standard
+
+D provee un mecanismo muy interesante y práctico, las propiedades.
+ Una clase (o estructura) puede tener métodos especiales que pueden ser
+ llamados como si fueran atributos de la clase.
+ No es más que azúcar sintáctico pero es muy útil y está implementado de
+ una forma muy simple.
+ Cualquier método que tenga un sólo argumento y devuelva un valor del mismo
+ tipo se convierte en una propiedad de escritura y cualquier método que
+ no tome argumentos y devuelva un valor se convierte en una propiedad de
+ lectura.
+ Incluyendo ambos se pueden tener propiedades de lectura/escritura.
+ Veamos un ejemplo:
+\layout LyX-Code
+
+class C
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+ int _i;
+\layout LyX-Code
+
+ int read() { return _i; }
+\layout LyX-Code
+
+ int write(int i) { return _i = i; }
+\layout LyX-Code
+
+ int rw() { return _i; }
+\layout LyX-Code
+
+ int rw(int i) { return _i = i; }
+\layout LyX-Code
+
+}
+\layout LyX-Code
+
+int main()
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+ C c = new C;
+\layout LyX-Code
+
+ // c.read = 1; NO COMPILA
+\layout LyX-Code
+
+ c.write = 2;
+\layout LyX-Code
+
+ printf("c.read = %d
+\backslash
+n", c.read);
+\layout LyX-Code
+
+ // printf("c.read = %d
+\backslash
+n", c.write); NO COMPILA
+\layout LyX-Code
+
+ c.rw = 3;
+\layout LyX-Code
+
+ printf("c.rw = %d
+\backslash
+n", c.rw);
+\layout LyX-Code
+
+ return 0;
+\layout LyX-Code
+
+}
+\layout Standard
+
+Además todos los tipos básicos poseen propiedades, algunas comunes a todos
+ (como
+\family typewriter
+sizeof
+\family default
+, que devuelve su tamaño, en general estos son todos resueltos en tiempo
+ de compilación) y otros particulares de cada tipo (como
+\family typewriter
+length
+\family default
+ para los array, que devuelve la cantidad de elementos que almacena).
+\layout Subsubsection
+
+Sobrecarga de operadores
+\layout Standard
+
+Otro mecanismo importante de abstracción que provee D es la sobrecarga de
+ operadores.
+ Se puede sobrecargar los operadores de clases y estructuras, de manera
+ tal de hacerlos ver sintácticamente como tipos nativos del lenguaje.
+ También es azúcar sintáctico y un caso particular de sobrecarga de funciones
+ (ver página
+\begin_inset LatexCommand \pageref{sub:Sobrecarga-de-funciones}
+
+\end_inset
+
+).
+\layout Subsection
+
+Seguridad
+\layout Standard
+
+D provee mecanismos de seguridad, tanto a nivel de módulo como de clase
+ y estructuras, aunque se ha comprobado empíricamente que el compilador
+ no lo está chequeando por el momento.
+ Por ejemplo, el siguiente código compila y corre:
+\layout LyX-Code
+
+class C
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+ private int i;
+\layout LyX-Code
+
+}
+\layout LyX-Code
+
+int main()
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+ C c = new C;
+\layout LyX-Code
+
+ c.i = 1;
+\layout LyX-Code
+
+ return 0;
+\layout LyX-Code
+
+}
+\layout Subsection
+
+Herencia
+\layout Standard
+
+El único tipo que permite herencia es class (y su sub-tipo interface).
+ D permite herencia simple entre clases comunes y una herencia múltiple
+ limitada a través de las interfaces.
+ Es decir, una clase sólo puede heredar de una sola clase, pero puede implementa
+r muchas interfaces.
+\layout Subsection
+
+Polimorfismo
+\layout Standard
+
+D implementa polimorfismo principalmente (pero no únicamente) a través de
+ las clases (e interfaces) y sus funciones virtuales, pero también a través
+ de la sobrecarga de funciones en general.
+\layout Subsubsection
+
+
+\begin_inset LatexCommand \label{sub:Polimorfismo-estático}
+
+\end_inset
+
+Polimorfismo estático
+\layout Standard
+
+D provee tipos genéricos, también conocidos en el mundo de los lenguajes
+ compilados como
+\emph on
+templates
+\emph default
+ o polimorfismo estático, ya que permite que una función o clase se comporte
+ de distinta manera pero se resuelve en tiempo de compilación.
+\layout Section
+
+Excepciones
+\layout Standard
+
+D provee un mecanismo de manejo de excepciones, con la sintaxis clásica
+ de tipo
+\family typewriter
+try-catch-finally
+\family default
+.
+ D, al igual que C++, dice que el manejo de excepciones puede no ser
+\emph on
+performance-critical
+\emph default
+, ya que debe manejar sólo casos muy esporádicos, situaciones inesperadas.
+ D es más consistente en el uso de excepciones que C++, ya que utiliza excepcion
+es en muchos lugares en la biblioteca estándar, cosa que C++ no suele hacer
+ y por lo cual el manejo de excepciones en ese lenguaje no suele ser muy
+ utilizado.
+\layout Standard
+
+Sin embargo no hay mucho más definido en D que la sintaxis del manejo de
+ excepciones, nada se define sobre el mecanismo (excepto en Windows, donde
+ dice que respeta la
+\emph on
+Microsoft Windows Structured Exception Handling
+\emph default
+).
+ Es por eso que me limitaré a ejemplificar el manejo de excepciones a un
+ ejemplo nada más:
+\layout LyX-Code
+
+int main()
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+ try
+\layout LyX-Code
+
+ {
+\layout LyX-Code
+
+ try
+\layout LyX-Code
+
+ {
+\layout LyX-Code
+
+ throw new Exception("first");
+\layout LyX-Code
+
+ }
+\layout LyX-Code
+
+ finally
+\layout LyX-Code
+
+ {
+\layout LyX-Code
+
+ printf("finally
+\backslash
+n");
+\layout LyX-Code
+
+ throw new Exception("second");
+\layout LyX-Code
+
+ }
+\layout LyX-Code
+
+ }
+\layout LyX-Code
+
+ catch(Exception e)
+\layout LyX-Code
+
+ {
+\layout LyX-Code
+
+ printf("catch %.*s
+\backslash
+n", e.msg);
+\layout LyX-Code
+
+ }
+\layout LyX-Code
+
+ printf("done
+\backslash
+n");
+\layout LyX-Code
+
+}
+\layout Standard
+
+Los bloques
+\emph on
+try-catch-finally
+\emph default
+ pueden estar anidados.
+\layout Section
+
+Paralelismo / Concurrencia
+\layout Standard
+
+D provee algunas pocas primitivas para el soporte de concurrencia.
+ En la biblioteca estándar provee una clase para ejecutar múltiples hilos
+ y provee en el lenguaje la palabra reservada
+\family typewriter
+synchronized
+\family default
+ para agregar bloqueo y desbloqueo de exclusión mutua (
+\emph on
+mutex
+\emph default
+) automáticamente antes y después (respectivamente) de bloque que encierra.
+ También puede usarse como clasificador de almacén (es decir, para proteger
+ una variable) o como modificador de una función (para proteger dicha función)
+ o de clase o de cualquier otra sentencia.
+\layout Standard
+
+Es necesario utilizar la clase
+\family typewriter
+Thread
+\family default
+ para ejecutar múltiples hilos ya que el recolector de basura tiene que
+ saber de todos los hilos que están corriendo para poder administrar su
+ memoria (y frenarlos ante un ciclo de recolección), aunque técnicamente
+ podría evitarse ya que se puede acceder a cualquier biblioteca de C (incluyendo
+ la de hilos).
+\layout Section
+
+
+\begin_inset LatexCommand \label{sec:Programación-segura}
+
+\end_inset
+
+Programación segura
+\layout Standard
+
+Uno de los objetivos principales de D es implementar técnicas de programación
+ segura, para tratar de evitar (o al menos detectar) la mayor cantidad de
+ errores de manera simple.
+ Veamos entonces algunos mecanismos que provee para satisfacer este objetivo.
+\layout Subsection
+
+Programación por contrato
+\layout Standard
+
+La programación por contrato consiste en imponer ciertas reglas que se cumplan
+ en distintos momentos del programa.
+ Básicamente provee 3 conceptos para verificar estos
+\emph on
+contratos
+\emph default
+:
+\emph on
+assert
+\emph default
+, invariantes de representación y pre y post condiciones.
+ Esto parece contradecir el objetivo de D de ser un lenguaje de alta performance
+, ya que si se hacen muchos chequeos, inevitablemente se sacrifica performance.
+ Pero esto no es necesariamente cierto, ya que todos estos mecanismos pueden
+ ser desactivados en tiempo de compilación, logrando tener un código para
+ depuración muy robusto y lleno de chequeos y un código para producción
+ muy eficiente y rápido.
+\layout Subsubsection
+
+assert
+\layout Standard
+
+Este es el tipo más básico de contrato, provisto también de una forma más
+ primitiva por C (a través del precompilador).
+ Simplemente evalúa en tiempo de ejecución que una expresión evalúe a
+\emph on
+true
+\emph default
+.
+ Si no es así, simplemente el programa lanza una excepción.
+\layout Subsubsection
+
+Invariante de representación
+\layout Standard
+
+Las clases puede incluir un invariante de presentación.
+ Esto es un fragmento de código que se ejecuta cada vez que se cambia una
+ instancia de la clase (excepto cuando los cambios se realizan desde una
+ función miembro.
+ Esto permite asegurar que los objetos estén siempre en estado consistente,
+ mientras se ejecute código que no conoce su representación.
+ Por ejemplo:
+\layout LyX-Code
+
+class Fecha
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+ int dia = 1;
+\layout LyX-Code
+
+ int mes = 1;
+\layout LyX-Code
+
+ invariant
+\layout LyX-Code
+
+ {
+\layout LyX-Code
+
+ assert(1 <= dia && dia <= 31);
+\layout LyX-Code
+
+ assert(1 <= mes && mes <= 12);
+\layout LyX-Code
+
+ }
+\layout LyX-Code
+
+ void p()
+\layout LyX-Code
+
+ {
+\layout LyX-Code
+
+ int d = dia;
+\layout LyX-Code
+
+ dia = 50; // ok, dentro de la clase no se chequea
+\layout LyX-Code
+
+ dia = d;
+\layout LyX-Code
+
+ printf("%02d-%02d
+\backslash
+n", dia, mes);
+\layout LyX-Code
+
+ }
+\layout LyX-Code
+
+}
+\layout LyX-Code
+
+Fecha f = new Fecha;
+\layout LyX-Code
+
+f.p(); // ok
+\layout LyX-Code
+
+f.dia = 40; // error!
+\layout Subsubsection
+
+Pre y post condiciones
+\layout Standard
+
+Toda función puede tener, además de su cuerpo, un bloque de código de pre-condic
+iones y/o un bloque de código de post-condiciones, que será ejecutado antes
+ y/o después de ejecutar la función (respectivamente).
+ Veamos un ejemplo:
+\layout LyX-Code
+
+long raiz(long x)
+\layout LyX-Code
+
+ in
+\layout LyX-Code
+
+ {
+\layout LyX-Code
+
+ assert(x >= 0);
+\layout LyX-Code
+
+ }
+\layout LyX-Code
+
+ out (result)
+\layout LyX-Code
+
+ {
+\layout LyX-Code
+
+ assert((result * result) == x);
+\layout LyX-Code
+
+ }
+\layout LyX-Code
+
+ body
+\layout LyX-Code
+
+ {
+\layout LyX-Code
+
+ return cast(long) std.math.sqrt(cast(float) x);
+\layout LyX-Code
+
+ }
+\layout Standard
+
+El parámetro del bloque
+\family typewriter
+out
+\family default
+ es el valor devuelto por el cuerpo de la función.
+ Entonces cuando se llame a
+\family typewriter
+raiz(8)
+\family default
+, el compilador (a menos que esté en modo
+\emph on
+release
+\emph default
+) lo traducirá a:
+\layout LyX-Code
+
+assert(8 >= 0); // ok
+\layout LyX-Code
+
+long tmp = raiz(8); // devuelve 2 por la conversión a long
+\layout LyX-Code
+
+assert((2 * 2) == 8); // error!
+\layout Subsection
+
+Casos de prueba
+\layout Standard
+
+D provee dentro del lenguaje herramientas para realizar casos de prueba
+ (
+\emph on
+unit tests
+\emph default
+) para asegurarse que una clase se comporte como debe.
+ Este código se ejecuta cuando se inicia el programa si se compila con la
+ opción de
+\family typewriter
+unittest
+\family default
+.
+ Por ejemplo:
+\layout LyX-Code
+
+class C
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+ unittest
+\layout LyX-Code
+
+ {
+\layout LyX-Code
+
+ assert(ok());
+\layout LyX-Code
+
+ }
+\layout LyX-Code
+
+ static bit ok() { return false; }
+\layout LyX-Code
+
+}
+\layout Standard
+
+Un programa que use esta clase saldrá apenas se inicia con una excepción
+ por el
+\family typewriter
+assert
+\family default
+.
+\layout Section
+
+Conclusiones
+\layout Standard
+
+Para analizar si el lenguaje cumple sus objetivos, vamos a analizar esos
+ objetivos (ver página
+\begin_inset LatexCommand \pageref{sub:Objetivo-del-lenguaje}
+
+\end_inset
+
+) punto por punto.
+ Para el análisis se asume que todo lo propuesto en el lenguaje está correctamen
+te implementado (que, como vimos a lo largo de este documento, no es necesariame
+nte cierto).
+\layout Paragraph
+
+Reducir el costo de desarrollo en al menos un 10% agregando características
+ que mejoren la productividad y ajustando las características del lenguaje
+ para que los errores más comunes que más cuestan reparar sean evitados
+ de base.
+\layout Standard
+
+Es difícil evaluar la ganancia en el costo de desarrollo (más aún si no
+ está claro en comparación a qué se quiere reducir el costo), pero sin dudas
+ el disponer de un recolector de basura, propiedades y otras muchas característi
+cas muy deseables deben reducir de forma considerable el costo de desarrollo.
+\layout Standard
+
+Con respecto a los mecanismos para evitar los errores más comunes, por lo
+ que he probado del lenguaje parece cumplirlo bastante bien, si uno se toma
+ el trabajo de utilizar todas las herramientas que se le provee, en particular
+ de las comentadas en la sección
+\begin_inset LatexCommand \vref{sec:Programación-segura}
+
+\end_inset
+
+.
+\layout Standard
+
+En términos generales podría decirse que sí, cumple este objetivo.
+\layout Itemize
+
+Hacer más fácil escribir programas portables entre compiladores, arquitecturas
+ y sistemas operativos.
+\layout Paragraph
+
+Soportar programación multi-paradigma; es decir, como mínimo, soportar los
+ paradigmas: imperativo, estructurado, orientado a objetos y programación
+ genérica.
+\layout Standard
+
+Definitivamente cumple con estos objetivos mínimos, es un lenguaje netamente
+ imperativo, con soporte de estructuras y todos los requerimientos de la
+ programación orientada a objetos (a través de las clases, ver sección
+\begin_inset LatexCommand \vref{sec:Orientación-a-objetos}
+
+\end_inset
+
+).
+ Además provee un mecanismo para programación genérica, a través de templates
+ (ver sección
+\begin_inset LatexCommand \vref{sub:Polimorfismo-estático}
+
+\end_inset
+
+).
+\layout Paragraph
+
+Tener una curva de aprendizaje corta para programadores que se sienten a
+ gusto con C o C++.
+\layout Standard
+
+Aunque tiene varias diferencias con C y C++, la sintaxis es muy similar
+ y su uso en general también.
+ Particularmente encuentro bastante molesto y confuso que las instancias
+ de clase se manejen por referencia (en realidad encuentro confuso que sean
+ una excepción).
+ A pesar de esto, sin dudas la curva de aprendizaje es corta (aunque no
+ nula), así que creo que este objetivo también lo cumple satisfactoriamente.
+\layout Paragraph
+
+Proveer acceso irrestricto de bajo nivel cuando sea necesario.
+\layout Standard
+
+Definitivamente también lo cumple.
+ Soporta punteros (pág.
+
+\begin_inset LatexCommand \pageref{sub:Punteros}
+
+\end_inset
+
+), assembly embebido (pág.
+
+\begin_inset LatexCommand \pageref{sub:Assembly-embebido}
+
+\end_inset
+
+), alocación de memoria manual (pág.
+
+\begin_inset LatexCommand \pageref{sub:Variables}
+
+\end_inset
+
+), control sobre el recolector de basura (pág.
+
+\begin_inset LatexCommand \pageref{sub:Recolección-de-basura}
+
+\end_inset
+
+), etc.
+\layout Paragraph
+
+Hacer que implementar un compilador sea mucho más sencillo que para C++.
+\layout Standard
+
+Esto tampoco puede ser evaluado certeramente de forma sencilla, pero viendo
+ como se simplificaron varias características de C++ que son particularmente
+ complicadas de implementar (como la herencia múltiple) es de esperarse
+ que hacer un compilador de D sea más sencillo que uno de C++, pero no podría
+ afirmarlo porque tampoco conozco las complicaciones que adhiere D con las
+ características no presentes en C++, como para saber cómo sale en el balance.
+\layout Paragraph
+
+Ser compatible con la ABI local de C.
+\layout Standard
+
+Lo cumple, puede interactuar con C sin inconvenientes.
+\layout Paragraph
+
+Tener gramática libre de contexto.
+\layout Standard
+
+Tampoco es algo que haya podido probar de forma sería, pero se eliminan
+ construcciones de C que dependían del contexto como
+\family typewriter
+(foo) - p;
+\family default
+ que en C/C++ puede ser interpretado como la resta de
+\family typewriter
+ p
+\family default
+ a
+\family typewriter
+foo
+\family default
+ si
+\family typewriter
+ foo
+\family default
+ es una variable o como
+\family typewriter
+-p
+\family default
+
+\emph on
+casteado
+\emph default
+ a
+\family typewriter
+foo
+\family default
+ si
+\family typewriter
+foo
+\family default
+ es un tipo definido por el usuario.
+ En D esa expresión es la resta, ya que para hacer el
+\emph on
+cast
+\emph default
+ hay que usar el operador:
+\family typewriter
+cast(foo) - p
+\family default
+.
+\layout Standard
+
+Entonces, si bien no puedo asegurar que el objetivo esté cumplido, sí puedo
+ asegurar que está más cercano a tener una gramática menos dependiente del
+ contexto que C/C++.
+\layout Paragraph
+
+Escribir fácilmente aplicaciones internacionalizadas.
+\layout Standard
+
+Tengo la sensación de haber visto en algún momento que había una forma de
+ poner literales de string internacionalizables en el lenguaje, con el siguiente
+ formato:
+\family typewriter
+_
+\begin_inset Quotes erd
+\end_inset
+
+hola
+\begin_inset Quotes erd
+\end_inset
+
+
+\family default
+.
+ Esa característica parece que no existe más, al menos en la documentación,
+ así que realmente no veo de qué manera se cumple este objetivo.
+\layout Paragraph
+
+Incorporar Programación por Contrato y metodologías de casos de prueba.
+\layout Standard
+
+Lo cumple muy bien, utilizando todo lo visto en la sección
+\begin_inset LatexCommand \vref{sec:Programación-segura}
+
+\end_inset
+
+.
+\layout Paragraph
+
+Ser capaz de construir programas independientes y livianos.
+\layout Standard
+
+Los programas son sin dudas menos livianos e independientes que los de C,
+ porque además de depender de la biblioteca estándar de C (aunque no depende
+ necesariamente, la biblioteca estándar de D la usa extensivamente), depende
+ de la biblioteca propia de D, que incluye al código del recolector de basura.
+ Compilando estáticamente, un programa que no hace nada:
+\layout LyX-Code
+
+int main()
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+ return 0;
+\layout LyX-Code
+
+}
+\layout Standard
+
+su versión en C y C++ ocupan 460KB, mientras que la versión en D ocupa 1.2MB.
+\layout Standard
+
+Sin embargo, si hacemos el clásico ejemplo de
+\emph on
+hello world
+\emph default
+:
+\layout LyX-Code
+
+int main()
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+ printf("hola mundo!
+\backslash
+n");
+\layout LyX-Code
+
+ return 0;
+\layout LyX-Code
+
+}
+\layout Standard
+
+Si la versión en C++ la escribimos usando la STL
+\begin_inset Foot
+collapsed false
+
+\layout Standard
+
+Standard Template Library (la biblioteca estándar de C++)
+\end_inset
+
+:
+\layout LyX-Code
+
+#include <iostream>
+\layout LyX-Code
+
+int main()
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+ std::cout << "hola mundo!
+\backslash
+n";
+\layout LyX-Code
+
+ return 0;
+\layout LyX-Code
+
+}
+\layout Standard
+
+En C sigue ocupa 461KB, en D sigue ocupando 1.2MB y la versión en C++ pasa
+ a ocupar 1.1MB, lo que pone en evidencia la alta complejidad de la biblioteca
+ estándar de C++.
+\layout Standard
+
+Por lo tanto, si bien D no puede ser tan liviano como C, sí puede sacarle
+ una buena ventaja a C++ en lo que es el manejo de
+\emph on
+strings
+\emph default
+ u otras estructuras que provee la STL en C++ que son muy complejas.
projects / z.facultad / 75.31 / presentacion.git / blobdiff