\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>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>
</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>
</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.
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.
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().
projects / z.facultad / 75.42 / string.git / blobdiff