From 8b5b260f89e1a5b49974aa23df9c5c36e66f9065 Mon Sep 17 00:00:00 2001
From: Leandro Lucarella <llucax@gmail.com>
Date: Tue, 30 Sep 2003 05:07:37 +0000
Subject: [PATCH] Se termina el informe.

---
 documentacion.h | 166 ++++++++++++++++++++----------------------------
 1 file changed, 70 insertions(+), 96 deletions(-)

diff --git a/documentacion.h b/documentacion.h
index e43fc02..be517ba 100644
--- a/documentacion.h
+++ b/documentacion.h
@@ -46,8 +46,8 @@ Tambi
         \subsubsection clase_ascii Clase Ascii.
             <table>
                 <tr>
-                    <th bgcolor="gray">Método / Operador</td>
-                    <th bgcolor="gray">Objetivo</td>
+                    <th>Método / Operador</td>
+                    <th>Objetivo</td>
                 </tr>
                 <tr>
                     <td>Ascii</td>
@@ -55,49 +55,31 @@ Tambi
                 </tr>
                 <tr>
                     <td>operador \<\<</td>
-                    <td>Volcado de su contenido a la salida estandar</td>
+                    <td>Volcado de su contenido a la salida estándar</td>
                 </tr>
                 <tr>
                     <td>operador \>\></td>
-                    <td>Captura de datos por la entrada estandar</td>
+                    <td>Captura de datos por la entrada estándar</td>
                 </tr>
                 <tr>
                     <td>operador =</td>
-                    <td>Asignacion de una instancia a otra</td>
+                    <td>Asignación de una instancia a otra</td>
                 </tr>
                 <tr>
                     <td>operador \<</td>
-                    <td>Comparacion por menor de dos instancias</td>
+                    <td>Comparación por menor de dos instancias</td>
                 </tr>
                 <tr>
                     <td>operador ==</td>
-                    <td>Comparacion por igual de dos instancias</td>
+                    <td>Comparación por igual de dos instancias</td>
                 </tr>
             </table>
 
-                \verbatim
-+----------------------------------------------------------------+
-| Metodo/operador | Objetivo                                     |
-|-----------------+----------------------------------------------|
-| Ascii           | Constructores                                |
-|-----------------+----------------------------------------------|
-| operador <<     | Volcado de su contenido a la salida estandar |
-|-----------------+----------------------------------------------|
-| operador >>     | Captura de datos por la entrada estandar     |
-|-----------------+----------------------------------------------|
-| operador =      | Asignacion de una instancia a otra           |
-|-----------------+----------------------------------------------|
-| operador <      | Comparacion por menor de dos instancias      |
-|-----------------+----------------------------------------------|
-| operador ==     | Comparacion por igual de dos instancias      |
-+----------------------------------------------------------------+
-            \endverbatim
-
         \subsubsection clase_unicode Clase Unicode.
             <table>
                 <tr>
-                    <th bgcolor="gray">Método / Operador</td>
-                    <th bgcolor="gray">Objetivo</td>
+                    <th>Método / Operador</td>
+                    <th>Objetivo</td>
                 </tr>
                 <tr>
                     <td>Unicode</td>
@@ -105,52 +87,34 @@ Tambi
                 </tr>
                 <tr>
                     <td>operador \<\<</td>
-                    <td>Volcado de su contenido a la salida estandar</td>
+                    <td>Volcado de su contenido a la salida estándar</td>
                 </tr>
                 <tr>
                     <td>operador \>\></td>
-                    <td>Captura de datos por la entrada estandar</td>
+                    <td>Captura de datos por la entrada estándar</td>
                 </tr>
                 <tr>
                     <td>operador =</td>
-                    <td>Asignacion de una instancia a otra</td>
+                    <td>Asignación de una instancia a otra</td>
                 </tr>
                 <tr>
                     <td>operador \<</td>
-                    <td>Comparacion por menor de dos instancias</td>
+                    <td>Comparación por menor de dos instancias</td>
                 </tr>
                 <tr>
                     <td>operador ==</td>
-                    <td>Comparacion por igual de dos instancias</td>
+                    <td>Comparación por igual de dos instancias</td>
                 </tr>
             </table>
 
-            \verbatim
-+----------------------------------------------------------------+
-| Metodo/operador | Objetivo                                     |
-|-----------------+----------------------------------------------|
-| Unicode         | Constructores                                |
-|-----------------+----------------------------------------------|
-| operador <<     | Volcado de su contenido a la salida estandar |
-|-----------------+----------------------------------------------|
-| operador >>     | Captura de datos por la entrada estandar     |
-|-----------------+----------------------------------------------|
-| operador =      | Asignacion de una instancia a otra           |
-|-----------------+----------------------------------------------|
-| operador <      | Comparacion por menor de dos instancias      |
-|-----------------+----------------------------------------------|
-| operador ==     | Comparacion por igual de dos instancias      |
-+----------------------------------------------------------------+
-            \endverbatim
-
-            Es importante destacar que se debe poder hacer una asignacion
+            Es importante destacar que se debe poder hacer una asignación
             de un objeto Unicode a un objeto Ascii y viceversa.
 
         \subsubsection clase_universalstring Clase UniversalString.
             <table>
                 <tr>
-                    <th bgcolor="gray">Método / Operador</td>
-                    <th bgcolor="gray">Objetivo</td>
+                    <th>Método / Operador</td>
+                    <th>Objetivo</td>
                 </tr>
                 <tr>
                     <td>UniversalString</td>
@@ -158,65 +122,47 @@ Tambi
                 </tr>
                 <tr>
                     <td>operador \<\<</td>
-                    <td>Volcado de su contenido a la salida estandar</td>
+                    <td>Volcado de su contenido a la salida estándar</td>
                 </tr>
                 <tr>
                     <td>operador \>\></td>
-                    <td>Captura de datos por la entrada estandar</td>
+                    <td>Captura de datos por la entrada estándar</td>
                 </tr>
                 <tr>
                     <td>operador =</td>
-                    <td>Asignacion de una instancia a otra</td>
+                    <td>Asignación de una instancia a otra</td>
                 </tr>
                 <tr>
                     <td>operador \<</td>
-                    <td>Comparacion por menor de dos instancias</td>
+                    <td>Comparación por menor de dos instancias</td>
                 </tr>
                 <tr>
                     <td>operador ==</td>
-                    <td>Comparacion por igual de dos instancias</td>
+                    <td>Comparación por igual de dos instancias</td>
                 </tr>
             </table>
 
-            \verbatim
-+----------------------------------------------------------------+
-| Metodo/operador | Objetivo                                     |
-|-----------------+----------------------------------------------|
-| UniversalString | Constructores                                |
-|-----------------+----------------------------------------------|
-| operador <<     | Volcado de su contenido a la salida estandar |
-|-----------------+----------------------------------------------|
-| operador >>     | Captura de datos por la entrada estandar     |
-|-----------------+----------------------------------------------|
-| operador =      | Asignacion de una instancia a otra           |
-|-----------------+----------------------------------------------|
-| operador <      | Comparacion por menor de dos instancias      |
-|-----------------+----------------------------------------------|
-| operador ==     | Comparacion por igual de dos instancias      |
-+----------------------------------------------------------------+
-            \endverbatim
-
-            De ser necesario, se puede implementar otros metodos a
+            De ser necesario, se puede implementar otros métodos a
             cualquiera de las tres clases.
 
-        \subsubsection funcion_template Funcion Template.
-            Implementar una funcion template que aplique un quicksort
+        \subsubsection funcion_template Función Template.
+            Implementar una función template que aplique un quicksort
             de los elementos de un vector de la STL.
             
-            Ej. de declaracion de la funcion template:
+            Ej. de declaración de la función template:
             \code
-Template \<class X\> void quicksort(std::vector\<X\>\& vec);
+template <class X> void quicksort(std::vector<X>& vec);
             \endcode
 
-        \subsubsection aplicacion Aplicacion.
-            Se debe desarrollar una aplicacion que guarde en dos
+        \subsubsection aplicacion Aplicación.
+            Se debe desarrollar una aplicación que guarde en dos
             vectores de manera distinta (Ascii y Unicode) las
             palabras que ingrese el usuario y  las ordene para
             luego imprimirlas por pantalla. Para ello, utilizar
             dos vectores de la STL, uno que contenga elementos de
             tipo UniversalString\<Ascii\> y otro de tipo
             UniversalString\<Unicode\>. Ordenar los vectores con la
-            funcion template quicksort. El menu de la aplicacion debe
+            función template quicksort. El menú de la aplicación debe
             ser el siguiente:
             \verbatim
 1. Ingresar Palabra al Vector Ascii.
@@ -227,31 +173,59 @@ Template \<class X\> void quicksort(std::vector\<X\>\& vec);
 6. Salir.
             \endverbatim
 
-            Si se elige la opcion 3, la aplicacion debe preguntar por el
+            Si se elige la opcion 3, la aplicación debe preguntar por el
             vector origen (desde que vector se copia la palabra) y el
-            numero de indice de la palabra a copiar; de esta manera,
+            numero de índice de la palabra a copiar; de esta manera,
             copiara la palabra al final del otro vector (queda a
             criterio del alumno el formato para preguntar al usuario por
-            esos dos datos: vector origen e indice). Cuando se listan
+            esos dos datos: vector origen e índice). Cuando se listan
             los vectores, con la opcion 5, junto a cada palabra se debe
-            mostrar el indice de la misma. Ante cualquier error detectado
-            el programa debera avisar por pantalla a traves del mensaje
+            mostrar el índice de la misma. Ante cualquier error detectado
+            el programa deberá avisar por pantalla a través del mensaje
             \c "ERROR".
 
-            \note La aplicacion debe liberar TODA la memoria alocada antes de
+            \note La aplicación debe liberar TODA la memoria alocada antes de
                   terminar.
 
 
 \section resolucion Resolución.
     \subsection res_ascii Clase Ascii.
-        TODO
+        Esta es la clase más simple. Un caracter es representado por un char por
+        lo que el comportamiento de esta clase es bastante obvio y predecible.
 
     \subsection res_unicode Clase Unicode.
-        TODO
+        Esta clase es levemente más compleja que Ascii. Un caracter es
+        representado por un short (2 bytes en plataformas de 32 bits
+        generalmente) por lo que se necesita de una conversión para lo que es la
+        entrada de datos (ya que las consolas comunes solo pueden ingresar
+        caracteres Ascii). La conversión es muy simple, sólo se ponen los 8 bits
+        más significativos en cero y los menos significativos con el valor del
+        caracter Ascii ingresado (un simple cast se encarga de esto). La
+        conversión inversa (de Unicode a Ascii, o char) es similar. Si los
+        primeros 8 bits (más significativos) son cero, se imprimen los últimos 8
+        bits (menos significativos) como si fueran un char (de nuevo un cast se
+        encarga de ello). En caso contrario, se imprimen 2 char (ya que las
+        consolas comunes no pueden mostrar un caracter Unicode), primero el de
+        los bits más significativos y luego el de los bits restantes.
 
     \subsection res_universalstring Clase Template UniversalString.
-        TODO
+        Esta es la clase más compleja. Además de ser la clase un \e Template,
+        hay un par de métodos que requieren otra caracterización (en general los
+        métodos para convertir de un tipo de string a otro, como el/los
+        constructor/es de \e copia,
+        UniversalString::UniversalString(const UniversalString<T2>&), y el
+        operador de asignación, UniversalString::operator=()).
+        Otro punto conflictivo es la entrada de datos. Para simplificarla se
+        hizo que se tome toda la frase entera (hasta el fin de línea) en vez de
+        una sola palabra, para lo cual se tubo que usar los modificadores de
+        streams skipws y noskipws.
+        El almacenamiento interno de caracteres se realizó a través de un vector
+        de la STL.
 
+    \subsection res_quicksort Función Template quicksort.
+        No hay mucho que comentar sobre quicksort(). Al estar todos los
+        operadores del UniversalString sobrecargados, hacer el quicksort fue
+        como hacer un quicksort para cualquier tipo de dato nativo del lenguaje.
 
 \section requerimientos Requerimientos y modo de uso.
     \subsection plataforma Plataforma y compilador.
@@ -275,10 +249,10 @@ Template \<class X\> void quicksort(std::vector\<X\>\& vec);
     Los mayores problemas se presentaron en la clase UniversalString, en
     particular en el operador para ingresar datos de un stream de entrada y en
     la conversión entre strings de distinto tipo de caracteres. Para eso tuve
-    que crear el método to_vector() para poder obtener el string de caracteres
-    desconocido en un formato conocido.
+    que crear el método UniversalString::to_vector() para poder obtener el
+    string de caracteres desconocido en un formato conocido.
     Con respecto a la entrada estándar, también tuve problemas con el \e buffer,
-    ya que en algunas ocaciones se capturaban solo parte de la entrada del
+    ya que en algunas ocasiones se capturaban solo parte de la entrada del
     usuario y a la hora de usar nuevamente el objeto cin, recibía los datos
     anteriormente entrados, comportamiento que no era deseado. Por eso tuve que
     usar en varios lugares el método istream::ignore().
-- 
2.43.0