UNIVERSIDAD DE COSTA RICA
ESCUELA DE LAS CIENCIAS DE LA COMPUTACIÓN E INFORMÁTICA
(ECCI)
PROGRAMACIÓN II (CI-1201)
CENTRO UNIVERSITARIO:
LISTA DE
LISTAS ENLAZADAS
(el caso
de los e-mail’s)
PROFESOR:
ADOLFO
DI MARE
27/09/2005
Tabla de contenidos
Descripción del problema a resolver
Especificación de los métodos:
Anteriormente, en otras
tareas, hemos contado con la ayuda del profesor cuando se nos incluyen archivos
iniciales para tener un punto de arranque, en ésta ocasión, recae sobre
nosotros la responsabilidad de desarrollar cada parte del programa, modularlo e
implementarlo. Aún la escogencia del compilador queda a nuestro gusto. Toda
ésta nueva experiencia nos brinda la oportunidad de crecer en nuestras
destrezas en programación, el desarrollo de técnicas saludables de
especificación es fundamental para que el trabajo en equipo dé los resultados
esperados. El buen uso de la abstracción será fundamental y el respeto a no
acceder al REP de la clase. Unos de los objetivos de éste trabajo es que el
estudiante aprenda a hacer primero la documentación del programa para que
posteriormente ésta sea usada como guía, sin embargo, por ser ésta la primera
vez que hacemos éste proceso es probable que el diseño aquí planteado varíe un
poco del resultado final.
Los documentos de este
trabajo, se pueden encontrar en: www.angelfire.com/cantina/colossus y
en: www.angelfire.com/rock4/a43354, documentaciones y archivos de
compilación.
Se debe tener una idea muy clara
de lo que significa el diseño, abstracción e implementación de una clase, pues
en este caso no hay un punto de partida, sino más bien hay que comenzar de
cero, hacer nuestras propias clases, métodos y demás.
El objetivo es separar las
direcciones de correo de entre información variada que recibimos de una gran
cantidad de archivos de texto de la firma spamTico.com, posterior a la
separación, debemos guardar un registro del renglón en el que aparece cada
dirección.
Para almacenar las direcciones
usaremos una lista de la biblioteca STL de C++, en ella se almacenarán objetos
tipo e-mail que tendrán cada uno una lista propia. En ésta lista propia de los
objetos e-mail se almacenarán duplicados del renglón en el que se encontró la
dirección.
Investigar acerca del uso de las
bibliotecas STL de C++.
Dividir el problema en módulos para su
fácil implementación
Seguir nuestras propias especificaciones
para aprender de nuestros errores durante la etapa de documentación
Profundizar en el uso del software
generador de especificaciones Doxygen.
El programa requiere tener una
plataforma de win32 valida con cualquier sistema operativo de Microsoft Windows;
además de que requiere la existencia de los sub-directorios que se deseen
ordenar.
Además de un archivo para
leer, este archivo va a contener cientos de páginas en la que van escritas
varias direcciones de correo.
Clase
Email:
/**
Se
encarga de crear nuevas listas de tipo \cemail las cuales van a apuntar a otra
lista que contenga los renglones en los que aparece cada dirección.
-
Se
encarga de hacer la parte más compleja del progama
-
Recibe
las direcciones y sus renglones respectivos para poder realizar su labor
**/
class
Email
Clase
p2-ta5:
/** En esta clase se encuentra el \cmain,
analiza el archivo para verificar que hayan direcciones de correo y las envía a
la otra clase para que las guarde como \clistas.
-
Recibe
un archivo de gran tamaño para extraer las direcciones de correo
-
Muestra
el resultado final con los emails y sus respectivos renglones
**/
class p2-ta-5
Método de Member:
/** Este método busca si
una dirección ya está dentro de la lista principal.
-
Si la
dirección está en la lista principal, quiere decir que ya existe un objeto tipo
email que contiene una lista propia para almacenar los renglones en los que
aparece la misma dirección, entonces sólo se agrega un duplicado del renglón en
el último campo de la lista propia de éste objeto.
-
Si la
dirección no está en la lista principal, entonces se agrega a ésta un nuevo
objeto de tipo email que recibe como parámetro la dirección que va a almacenar.
**/
void list :: Member (const email &aBuscar)
Método InsertEmail:
/** Su función es crear
un objeto tipo email y agregarlo a la lista principal. Éste método recibe por
parámetros la dirección de correo que va a almacenar el nuevo objeto.
void list :: InsertEmail (const string
&direccion)
Método InsertRenglon:
/** Su función es agregar un duplicado a la lista
propia de email del renglón en el que apareció la dirección. Éste método recibe
por parámetro el renglón que va a agregarse.
void list :: InsertRenglon (const string
&renglon)
Éste programa sirve para extraer
direcciones de correo electrónico de un texto y guardar un registro de cada
renglón en el que aparece dicha dirección. Al final, imprime una lista
intercalada de correos seguidos por los renglones en los que apareció cada uno. Se
imprime de la siguiente forma:
cbadillam@yahoo.com: - Te envié el
mensaje al correo cbadillam@yahoo.com
pero no me has contestado…
- …cuando me fijé no había escrito el .com
de cbadillam@yahoo.com, ya yo…
adolfo@di-mare.com: - … cuando
el profesor Adolfo (adolfo@di-mare.com)
envió el correo, yo estaba chateando con…
- …<adolfo@di-mare.com> Mail delivery failure, mailbox
full or message is larger than…
Éste programa es muy eficiente
en cuanto no interactúa con el usuario, por lo que no hay errores posibles a la
hora de recibir la información. También reconoce todos los caracteres aceptados
en direcciones de correo electrónico(letras, números y los caracteres ‘-‘,’_’,
‘.’, ‘@’) por lo que no hay manera de que falte alguna dirección. Como usa las
listas que proporciona la biblioteca STL de C++, éstas crecen sin parar hasta
que la memoria se agota, así que ése es el límite de direcciones que soporta, y
varía de una máquina a otra.
Lista principal Lista propia de cada objeto email
+------------------+
+----------------------------------------------------------+
cbadillam@yahoo.com => Te envié el mensaje al correo cbadillam@yahoo.com pero no me has
contestado…
+------------------+
+----------------------------------------------------------+
+----------------------------------------------------------+
=>
…cuando me fijé no había escrito el .com de cbadillam@yahoo.com, ya yo…
+----------------------------------------------------------+
+------------------+
+----------------------------------------------------------+
adolfo@di-mare.com => cuando
el profesor Adolfo (adolfo@di-mare.com)
envió el correo, yo estaba chateando con…
+------------------+
+----------------------------------------------------------+
+----------------------------------------------------------+
=>
…<adolfo@di-mare.com> Mail
delivery failure, mailbox full or message is larger than…
+----------------------------------------------------------+
. . . . . .
El compilador utilizado fue Microsoft
Visual C++ 7.0
La presentación del trabajo permite que el
estudiante simplemente abra el proyecto que se encuentra en el archivo .ZIP y abra
el proyecto para Visual C++, automáticamente se cargan los archivos necesarios
para la compilación y ejecución del programa.
Luego se compila el programa y una vez
hecho esto, estará listo para ser ejecutado.
Guía de uso del programa
En nuestro caso,
simplemente se ejecuta el programa y él mismo carga el archivo que va a
utilizar, extrae cada dirección y su respectivo renglón y finalmente imprime el
resultado. Todo lo hace sin solicitar la asistencia del usuario, por lo que no
hay mayores complicaciones.
Conclusiones
Definitivamente,
la etapa más difícil de un programa es su correcta especificación, su claro
planeamiento y la modulación necesaria. Tuvimos algunos problemas a la hora de definir
los métodos a utilizar, porque no sabíamos si estábamos contemplando todas las
posibilidades y si estábamos usando la cantidad de métodos suficientes o al
menos los indicados. Al principio éstas dudas nos llevaron a pensar que
estábamos haciendo algo mal, pues el objetivo de hacer primero la
especificación es dar una idea más clara a los programadores de lo que hay que
hacer mientras que lo que habíamos generado como documentación sólo nos
obligaba a usar los métodos que habíamos planteado y sentíamos que el programa
se volvía rígido, entonces decidimos plantear de nuevo la especificación de los
métodos y de la clase. Luego de analizar nuestra documentación anterior,
descubrimos huecos en el programa que no habíamos contemplado, lo que nos ayudó
a aclarar la estructura que el software debía tener. Redefinimos los métodos
mediante una modulación mejor planeada: implementamos métodos para agregar los
renglones y eso aclaró la idea que teníamos del programa. Luego de generar la
documentación que nos pareció más indicada, procederemos a programar un
software que a primera vista parecía imposible, mas luego de la especificación
y modulación se ha vuelto un reto que no dudamos poder completar con éxito.
Esperamos generar código eficiente y fácil de leer, con especificaciones mejor
elaboradas y con un profundo sentido de la simplicidad.
-
Deitel Harvey M., Deitel Paul J. Como programar en C++. Segunda Edición.
Pearson Educación, México, 2003.
