Site hosted by Angelfire.com: Build your free website today!

 

 

 

 

 

Universidad de Costa Rica

 

 

Manuel Marín Mora

A33018

 

 

 

Programación II

Prof: Adolfo Di Mare

 

 

Tarea 3

 

 

2005

 

 


Índice

 

Introducción_ 3

Descripción del Problema 4

Planteo_ 4

Objetivos 4

Requerimientos 4

Abstracción_ 5

Especificación de la Clase 5

Operaciones y Métodos 5

Eficiencia 5

Especificación del Programa 5

Implementación_ 7

Modelo de la clase 7

Invariante de la clase 8

Arquitectura Interna del Programa 8

Compilador Usado_ 9

¿Como Compilar? 9

Guía de Uso del Programa 10

Reconocimientos 10

Bibliografía 11

 

 


Tarea Programada # 3

 

Introducción

La presente documentación forma parte de la Tarea Programada # 3 del curso de Programación II de la escuela de Ciencias de la Computación e Informática de la Universidad de Costa Rica, el cual es impartido por el profesor Adolfo Di Mare H.

Toda la implementación presentada en este documento, esta escrita en el lenguaje C++ estándar, y diseñado básicamente para funcionar en Aplicaciones de consola para plataformas que corren bajo win32 (win32 console aplication).

La información adicional como lo es: el código fuente, la documentación interna y la documentación con Doxygen se encuentran disponibles en la siguiente dirección:

http://www.angelfire.com/hero2/3m19

En este sitio se encuentra disponible una documentación mas detallada, junto con enlaces de ayuda, y todo el código fuente de las clases utilizadas para la solución del problema.

 


Descripción del Problema

Planteo

Descripción brindada por el Prof. Adolfo Di Mare, el objetivo de esta tarea programada es forzarle a usar especificación en lugar de implementación de una clase.

int main() {
    Mnbag B;
    long n;
 
    // lee todos los valores
    while (cin >> n) {
        B.Inc(n);
    }
 
    for (n=0; n<LONG_MAX; ++n) {
        if (0 != B[n]) {
            cout << n << " está " << B.Qty(n);
            cout << " veces en la bolsa" << endl;
        }
    }
 
    return 0;
} // main()

Figura 1

El programa de la Figura 1 sirve para leer números y contar cuántas veces aparece cada uno. Complete la clase "Nmbag" vista en clase para implementar este programa.

También la puede encontrar esta especificación en la siguiente dirección http://www.di-mare.com/adolfo/cursos/2005-2/p2-ta-3.htm

 

Objetivos

El objetivo principal de esta tarea el la creación de una bolsa de números que sea capaz de leer los datos introducidos por el usuario y devuelva la cantidad de veces que cada número se encuentra en la bolsa.
Otro objetivo es la especificación del método Qty ( ) y el método Inc ( ), para lo que se necesitara entender el código implementado por el Profesor Di Mare en Pascal.

Requerimientos

La bolsa debe de recibir números enteros y ser capaz de devolver la cantidad de veces que se repite cada número introducido.

 


Abstracción

 

Especificación de la Clase

Para la especificación de la clase podemos decir que una bolsa de números “Nmbag” es un conjunto de dos arreglos, uno que guarda los números digitados por el usuario, y otro que guarda la cantidad de veces que se repite el número en el otro arreglo:

·        Un arreglo de tipo int (m_val []), guarda los valores digitados.

·        Un arreglo de tipo long (m_count []), guarda la cantidad de veces que se repite cada número en la bolsa.

 

 

Operaciones y Métodos

La clase Count.cpp es la clase principal del programa, esta contiene el main ( ), que crea un objeto B de tipo Nmbag  y llama a los métodos de  B.Inc ( ) y B.Qty ( ), que se encuentran en unos ciclos para leer e imprimir los valores. 

Además, en la clase Nmbag.cpp se encuentran los siguientes métodos:

·        check_ok ()” que sirve para verificar la invariante de la clase. 

·        Nmbag::Qty ()”que sirven para forzar retornar la cantidad de veces se repite un valor “n” en la bolsa.

·        Nmbag::Inc()” que incrementa en 1 el valor de Qty (n).

 

Eficiencia

El programa obtiene una buena eficiencia al contar la cantidad de números de una manera acertada.

 

Especificación del Programa

Para los objetos de tipo Nmbag hay constructores y destructores,  además de los métodos ya antes mencionados y la definición de las variables m_used que es la cantidad de valores almacenados en la bolsa,  en si el programa es capaz de recibir una cantidad de números (255 como máximo, no repetidos) y devolver la cantidad que se repite cada uno de ellos, según como los halla introducido el usuario, si digita un valor que ya esta, no lo graba de nuevo, sino lo analiza y aumenta el valor de m_count[] del número digitado.


Implementación

 

Modelo de la clase

 

En nuestro programa, cada valor numérico digitado por el usuario se almacena en un campo de un vector, y la cantidad de veces que se repite ese término en otro que podríamos decir “se encuentra en paralelo” al anterior.

   0     1     2     3     4     5            Capacity

+-----+-----+-----+-----+-----+-----+ ... +-----+-----+

| @$? | ^-* | ¿!/ | !+* | @$? | ?!? | ... | @*? | ^-* | <== m_val[]

+-----+-----+-----+-----+-----+-----+ ... +-----+-----+

| ¿=^ | ¿?¿ | ^-* | /$% | @$? | )!/ | ... | @$? | !+* | <== m_count[]

+-----+-----+-----+-----+-----+-----+ ... +-----+-----+

                        

                       

    m_used == ###

 

 

 

 

Para el modelo de la clase utilizaremos un pequeño ejemplo:

 

 

La bolsa "B" contiene 3 valores cuya cuenta es mayor a cero:

 

        B.Qty(315) ==  13        B.Qty(1)  == 0

        B.Qty(212) ==   1        B.Qty(12) == 0

        B.Qty(304) == 500        B.Qty(17) == 0

 

   0     1     2     3     4     5            Capacity

+-----+-----+-----+-----+-----+-----+ ... +-----+-----+

| 315 | 212 | 304 |  1  | @$? | ?!? | ... | @*? | ^-* | <== m_val[]

+-----+-----+-----+-----+-----+-----+ ... +-----+-----+

|  13 |  1  | 500 |  12 | @$? | )!/ | ... | ?!? | @$? | <== m_count[]

+-----+-----+-----+-----+-----+-----+ ... +-----+-----+

                      ^

                     /|\

                      |

    m_used == 3 ------+

 

 

 

Además podemos expresar todo el programa con el siguiente diagrama, que especifica los #include`s de todo el programa:

 

 

 

Diagrama de "#include's"

 

                  +--------------+

                  | "ADH_port.h" |

+--------------+  +--------------+  

|  <iomanip>   |         |         

|  <climist>   |   +------------+    +--------------+

|  <iostream>  |   |  Nmbag.h   |    |  <assert.h>  |

+--------------+   +------------+    +--------------+

       |             /       \            |       

       |            /         \           |

       |           /           \          |

       |          /             \         |

       |         /               \        |

    +--------------+           +-------------+

    |  count.cpp   |           |  Nmbag.cpp  |

    +--------------+           +-------------+

           |                          |

           |                          |

    +--------------+           +-------------+

    |  count.obj   |           |  Nmbag.obj  |

    +--------------+           +-------------+

               \                 /

                \               /

                 \             /

                  \           /

                   \         /

                 +-------------+

                 |  Nmbag.exe  |

                 +-------------+

 

 

Invariante de la clase

 

Como la clase “Nmbag”, tiene dos vectores: el de los valores almacenados en la bolsa “m_val[]”, y el que contiene la cantidad de veces que cada valor aparece en la bolsa “m_count[]” y además estos vectores tienen como dimensión  Nmbag::Capacity”, sólo se puede almacenar un máximo de “Nmbag::Capacity” valores en la bolsa.

 

Entonces se puede decir que la invariante de esta clase es el valor de “m_used” que indica cuántos valores del vector están en uso; si la bolsa está vacía, se dice que el valor de “m_used” es  igual a cero. En los vectores los campos que se encuentran a partir de “m_val[m_used]” contienen  basura porque no están inicializados, por ende para la evaluación e impresión de los datos solo se toman los valores  que están hasta “m_val[m_used]”.

 

 

 

Arquitectura Interna del Programa

El programa en si esta compuesto por varias clases:

 

Compilador Usado

Para la resolución de la tarea se utilizo el compilador del Visual Studio C++ v.6 y Visual Studio C++ v.7 (Microsoft Visual Studio.NET 2003), el cual no debería de generar problemas a la hora de compilar ni de crear el ejecutable.

 

¿Como Compilar?

Para compilar el programa en el Microsoft Visual Studio.NET 2003, basta con crear un nuevo proyecto, ingresando a “file”, luego en “new” y a continuación Project o presionando las teclas Ctrl + Shift + N.
 
En la pantalla que aparecerá seleccione en “Projects Types” “Visual C++”, y “win32”, luego en “Templates” seleccione “Win32 Console Project”, en “Location” seleccione el directorio en el que desea que se copien los archivos creados.

A continuación en la pantalla “Win32 Application Wizard”, en “Application Settings” seleccione las casillas “Console Application” y “Empty Project”
 
Luego copie los archivos .ccp  y .h en el directorio seleccionado anteriormente (el que se creo durante la creación del proyecto). Una vez hecho esto en el “Solution Explorer”, seleccione el proyecto, luego en la carpeta “Source Files” y con un clic derecho seleccione “Add”, “Add existing item” y adhiere los .cpp, además en la carpeta “Header Files”, hace lo mismo solo que con los .h. 
 
El Proyecto ya esta listo para ser compilado, en “Build” seleccione “Build Solution” (o “Ctrl” +”Shift” +”B”).


Guía de Uso del Programa

Para la utilización del programa, primero ejecútelo (ya sea haciendo doble clic en el .exe generado o con el Visual Studio), luego digite los números que quiere introducir a la bolsa, cuando ya no desea introducir otro valor, digite cualquier EOF válido, por ejemplo una coma (,), un punto (.), cualquier carácter que no sea un número y presionar la tecla Enter, para devolver el resultado.

 

Datos de Prueba del Programa

Formato de los Datos de Prueba

 

Para el formato de los datos de prueba se pueden tomar cualquier valor entero (int), separado por cualquier cantidad de espacios o por cambios de línea. 

Entradas vs Salidas esperadas

 

A la hora de introducir los datos se debe de tener cuidado de solo introducir números enteros, ya que si se introducen números con decimales o en formato de fracción, el programa solo leerá los primeros valores introducidos antes de la coma, punto o barra inclinada digitada, y los demás valores digitados después, no se toman en cuenta.

 

Por ejemplo si el usuario digita:

 

10 10 10 5 6 6 3 1 2 3 2 4 2 3 4 5 ^D

 

Aparecerá algo como esto:

 

1     se encuentra 1 veces en la bolsa

2     se encuentra 3 veces en la bolsa

3     se encuentra 3 veces en la bolsa

4     se encuentra 2 veces en la bolsa

5     se encuentra 2 veces en la bolsa

6     se encuentra 2 veces en la bolsa

10    se encuentra 3 veces en la bolsa

 

Pero si digita:

 

10 10 10 5 5 6.7 6 3 1 2 3 2 4 2 3 4 5 ^D

              ^

              |

 

Aparecerá algo como esto:

 

5     se encuentra 2 veces en la bolsa

6     se encuentra 1 veces en la bolsa

10    se encuentra 3 veces en la bolsa 

 

Reconocimientos

 

Un agradecimiento muy especial al profesor Adolfo Di Mare que aportó parte del código y los conocimientos necesarios para la realización de esta tarea. Además de que nos brindo algunas soluciones a los errores que nos daba al compilar, se le agradece la implementación de ADH_port.h, ya que con este encabezado nos facilita la compilación con diferentes compiladores.

 

Bibliografía

Deitel & Deitel, Como Programar en C++, Cuarta Edición, Persons Education, México 2003

http://www.di-mare.com/adolfo/p/Matrix.htm

http://www.di-mare.com/adolfo/cursos/2005-2/p2-ta-3.htm