ESCUELA DE LAS CIENCIAS DE LA COMPUTACIÓN E INFORMÁTICA
(ECCI)
PROGRAMACIÓN II (CI-1201)
CENTRO UNIVERSITARIO:
USO DE
DICCIONARIOS (Map)
(Obtener
e-mail’s)
PROFESOR:
ADOLFO
DI MARE
14/10/2005
Tabla de contenidos
Descripción del problema a resolver
Especificación
de los métodos:
Esta tarea esta muy basada en
la anterior, lo único que va a cambiar es que ya no hay que hacer una lista de emails
que contengan una dirección y una lista de los renglones en los que
aparecieron. Ahora simplemente se hace
un mapa que contenga las direcciones y la lista de los renglones, como se puede observar esta tarea es más
sencilla que la anterior e interesante.
El uso de mapas es muy
beneficioso dependiendo de la situación, pero
por lo menos en programas en los que haya que utilizar algo asociado a
otra cosa es de mucho provecho su uso.
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.
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 mapas biblioteca STL de C++, en ellos se almacenará un e-mail tipo
string y como su par una lista que contiene los renglones respectivos en los
que aparecieron las direcciones.
·
Investigar
acerca del uso de las bibliotecas STL de C++.
·
Dividir
el problema en módulos para su fácil implementación
·
Aprender
a utilizar mapas
·
Reutilizar
nuestro propio código para futuras tareas
·
Poder
discernir entre el camino más simple para resolver un problema y el camino más
difícil a seguir
·
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.
/** En esta clase se encuentra el \cmain,
que hace llamado al método que analiza el archivo para verificar que hayan
direcciones de correo, luego extrae renglón
por renglón para poder analizarlo y extraer los \cmails que contengan.
-
Inserta
los renglones en una lista
-
Agrega
los \cmails y las listas de \crenglones a un mapa.
-
Es la
única clase que hay, pues sería
innecesario hacer otra.
**/
class Cbmap
/** Este método lee un \carchivo.txt y lo va analizando hasta que el texto en el documento se termine, sin importar la longitud de este.
-
Si no
posee direcciones de correo, no imprime nada y sale del archivo.
-
Si
hay líneas en blanco, no las toma en cuenta
-
Hace
llamado al \cExtractor cada vez que haya un correo electrónico y le envía por
parámetros la línea en que lo encontró.
**/
void
leer_archivo()
/** Hace una copia del
renglón que recibe, luego sustituye por asteriscos los caracteres no válidos
para poder conseguir las direcciones con mayor facilidad.
-
Si la
no posee ningún correo sale del método para evaluar al siguiente.
-
Si el
arroba esta en el último caracter no lo toma en cuenta.
-
Si
posee menos de cuatro caracteres, no es válido para una dirección de correo.
bool Extractor(const string &renglon)
/** Recibe la dirección de correo y el renglón
donde esta se encuentra, luego inserta en un diccionario el \cmail y una lista
de renglones
-
Si la
dirección ya esta en el diccionario, hace una copia de la lista que le hace par
e inserta el nuevo renglón.
-
Si no existe hace un nuevo espacio para el
correo y una nueva lista que contenga su línea.
**/
void Insertar(const string &direccion, const
string &renglon)
/** Hace un recorrido por
el diccionario y va imprimiendo sus \cmails con sus respectivas listas, para
imprimir los valores de las listas hace llamado al método \cImprimirLista()
**/
/** Recorre cada lista en
la posición respectiva en el diccionario y va copiando sus valores para al
final retornarlos.
**/
string ImprimirLista(const list<string>
&listilla)
É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 un mapa con direcciones de correo y listas con renglones. Se
imprime de la siguiente forma:
- 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…
- … 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++, además usa mapas;
ambos crecen sin parar hasta que la memoria se agota, así que ése es el límite
de pares y de renglones que soporta, y varía de una máquina a otra.
DICCIONARIO
||
\/
. . .
+----------+-----------+ +-------------------+-------------------...
¦ first
| second |
<=> |adolfo@di-mare.com
|renglon1|renglon10|...
+----------+-----------+
+-------------------+-------------------...
. . .
+----------+-----------+
+-------------------+-------------------...
¦ first
| second | <=> |anthonymr@gmail.com|renglon8|renglon2 |...
+----------+-----------+
+-------------------+-------------------...
+----------+-----------+ +-------------------+-------------------...
¦ first
| second | <=> |cbadillam@yahoo.com|renglon3| ...
|...
+----------+-----------+
+-------------------+-------------------...
. . .
+----------+-----------+
+-------------------+-------------------...
¦ first
| second | <=> |zz_zz.z@progra2.com|renglon1| ... |
+----------+-----------+
+-------------------+-------------------...
||
|| || ||
\/ \/ \/ \/
string list<string> llave de acceso cada renglonX
representa un
string
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.
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.
En esta ocasión no nos fue tan complicada
la realización del trabajo, solo que se nos presentaron igual número de
inconvenientes que la tarea anterior, como lo son los errores de linking. Pero lo mejor de todo fue que ya pudimos
detectar cuales son esos errores que son propios del compilador: el compilar en
la unidad z, hacer un nuevo proyecto jalando archivos que están en otra carpeta,
o hacer llamado a un método que aún que está en las líneas de abajo aunque esté
bien implementado, sabemos que este
último error es algo difícil de encontrar pues en java estábamos acostumbrados
a implementar los métodos en cualquier parte del código sin que esto afectara a
la hora de ejecución.
Sabemos que con
esta tarea se nos facilita el uso de mapas, pues en el libro solo vienen
ejemplos con números y eso no es del todo claro a la hora de trabajar con
objetos; ahora sí podemos decir que podemos usar mapas con objetos para
cualquier tipo de aplicación.
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. 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.
