Se agrega la carátula.

[z.facultad/75.42/string.git] / documentacion.h

diff --git a/documentacion.h b/documentacion.h
index e43fc02803dded2b224cef2fb05a77434e99016c..be517ba0b6b0f2a5176b51e4795d46a914385eca 100644 (file)
--- a/documentacion.h
+++ b/documentacion.h
@@ -46,8 +46,8 @@ Tambi
         \subsubsection clase_ascii Clase Ascii.
             <table>
                 <tr>
         \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>
                 </tr>
                 <tr>
                     <td>Ascii</td>


@@ -55,49 +55,31 @@ Tambi
                 </tr>
                 <tr>
                     <td>operador \<\<</td>
                 </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>
                 </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>
                 </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>
                 </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>
                 </tr>
                 <tr>
                     <td>operador ==</td>

-                    <td>Comparacion por igual de dos instancias</td>
+                    <td>Comparación por igual de dos instancias</td>

                 </tr>
             </table>
 
                 </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>
         \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>
                 </tr>
                 <tr>
                     <td>Unicode</td>


@@ -105,52 +87,34 @@ Tambi
                 </tr>
                 <tr>
                     <td>operador \<\<</td>
                 </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>
                 </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>
                 </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>
                 </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>
                 </tr>
                 <tr>
                     <td>operador ==</td>

-                    <td>Comparacion por igual de dos instancias</td>
+                    <td>Comparación por igual de dos instancias</td>

                 </tr>
             </table>
 
                 </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>
             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>
                 </tr>
                 <tr>
                     <td>UniversalString</td>


@@ -158,65 +122,47 @@ Tambi
                 </tr>
                 <tr>
                     <td>operador \<\<</td>
                 </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>
                 </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>
                 </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>
                 </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>
                 </tr>
                 <tr>
                     <td>operador ==</td>

-                    <td>Comparacion por igual de dos instancias</td>
+                    <td>Comparación por igual de dos instancias</td>

                 </tr>
             </table>
 
                 </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.
 
             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.
             
             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
             \code

-Template \<class X\> void quicksort(std::vector\<X\>\& vec);
+template <class X> void quicksort(std::vector<X>& vec);

             \endcode
 
             \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
             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.
             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
 
 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
             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
             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
             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".
 
             \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.
                   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.
 
     \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.
 
     \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.
 
 \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
     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,
     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().
     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().