Metodologia de La Programacion Cap 1

M. Sc. Ing. Lucas Coaquira Cano 1

CAP. 1.

MODULARIDAD. TIPOS

ABSTRACTOS DE DATOS

FUNDAMENTOS DE LENGUAJE DE PROGRAMACION


1.1 MODULARIDAD

La modularidad es la posibilidad de subdividir una

aplicación en piezas mas pequeñas (denominadas

módulos), cada una de las cuales debe ser tan

independiente como sea posible, considerando la aplicación

como un todo, así como de las otras piezas de las cuales es

una parte.

En esencia las abstracciones se implementan en módulos,

conocidos en la terminología de Booch como objetos, que

se agrupan en una sola entidad:

• Un conjunto de datos

• Un conjunto de operaciones que actúan sobre los datos



1.1.1 La estructura de un modulo

Un modulo se caracteriza fundamentalmente por su interfaz y por su

implementación.

Primitivas de acceso

Descripción de propiedades de los datos

Atributos Algoritmos

Representación Parámetros actuales

Interfaz

Sección

privada

Figura 1.1. Estructura de un modulo

1.1.2 Reglas de modularizacion

Un método de diseño debe ayudar al programador a resolver un

problema, dividiendo el problema en subproblemas mas pequeños, que

se puedan resolver independientemente unos de otros. También debe

ser fácil conectar los diferentes módulos a los restantes



Para obtener módulos con las características anteriores deben seguirse

las siguientes reglas:

Unidades modulares

El lenguaje debe proporcionar estructuras modulares con las cuales se

puedan describir las diferentes unidades.

Interfaces adecuados

En la estructuración de un programa en unidades es beneficioso que

existan pocos interfaces y que estos sean pequeños.

Pocos

interfaces

Muchos

interfaces

Figura 1.2. Interfaces adecuados (pocos – muchos)



Parte

visible

Interfaces

grandes

Interfaces

pequeños

Figura 1.3. Interfaces adecuados (grandes – pequeños)

Parte

visible



Interfaces explícitos

El interfaz o parte visible externamente de un modulo se debe declarar y

describir explícitamente; el programa debe especificar cuales son los

datos y procedimientos que un modulo trata y cuales deben permanecer

ocultos del exterior.

Ocultación de la información

Todos los módulos deben seguir el principio de ocultación de la

información.



1.2 DISEÑO DE MODULOS

1.2.1 Acoplamiento de módulos

El acoplamiento es una medida de interdependencia entre módulos, es decir, el

modo en que un modulo esta afectado por la estructura interna de otro modulo.

1.2.2 Cohesión de módulos

La cohesión describe la naturaleza de las interacciones dentro de un modulo

software. Es decir un módulo cohesivo solo hace (idealmente) una cosa (o

realizar una sola funcion relacionada con el problema).

Tipo de acoplamiento Grado de acoplamiento Grado de mantenibilidad

Por contenido Alto (fuerte) Bajo

Común

De control

Por sellado (estampado)

Datos

Sin acoplamiento Bajo (débil) Alto

Tabla 1.1 Clasificación del acoplamiento de módulos

LENGUAJE DE PROGRAMACION


Tipo de cohesión Grado de cohesión Grado de mantenimiento

Por coincidencia Bajo Bajo

Lógica

Por procedimientos

Por comunicaciones

Secuencial

Funcional

Informacional Alto Alto

Tabla 1.2 Clasificación de cohesión de módulos

Idealmente, se busca módulos altamente cohesivos y débilmente acoplados.

1.3 TIPOS DE DATOS

Un tipo de dato es un conjunto de valores y un conjunto de

operaciones definidas por esos valores.

Representación + Operaciones

LENGUAJE DE PROGRAMACION


1.4 ABSTRACCION EN LENGUAJES DE

PROGRAMACION

Los tipos de datos que se construyen en un compilador de

este modo se conocen como tipos de datos fundamentales

(predefinidos) y, por ejemplo, en C y C++ son entre otros, int, char y float.

Los lenguajes de programación (LP) son las herramientas

mediante las cuales los diseñadores de lenguajes pueden

implementar los modelos abstractos.


La abstracción ofrecida por los LP se puede dividir en dos categorías:

Abstracción de control y Abstracción de datos.


Abstracción

Propiedad que permite representar las características mas esenciales de un objeto, sin preocuparse de las restantes características (no esenciales).

La abstracción como proceso natural mental

Las persona comprenden mejor el mundo construyendo modelos mentales


1.4.1 Abstracciones de control

Los primeros lenguajes de programación de alto nivel introdujeron las

estructuras de control: sentencias de bifurcación (if) y bucles (for, while,

do-loop, etc.).

Abstracción procedimental (por procedimientos)

Utilización de procedimientos o funciones

Otros mecanismos de abstracción de control

Tales como manejo de excepciones, corrutinas, unidades concurrentes,

plantillas.

1.4.2 Abstracción de datos

Es la técnica de programación que permite inventar o definir nuevos

tipos de datos (tipos de datos definidos por el usuario) adecuados a la

aplicación que se desea realizar.

Los nuevos tipos de datos definidos por el usuario se llaman tipos

abstractos de datos.



1.5 TIPO ABSTRACTO DE DATO (TAD)

Un tipo definido por el programador se denomina tipo abstracto de

dato, TAD (Abstract Data Type).

La modularizacion de un programa utiliza la noción de tipo abstracto de

dato (TAD) siempre que sea posible. Si el TAD soporta los tipos que

desee el usuario y el conjunto de operaciones sobre cada tipo, se

obtiene un nuevo tipo de dato denominado objeto.

La implementación de un tipo abstracto de dato consta de:

1. La representación: elección de las estructuras de datos.

2. Las operaciones: elección de los algoritmos.



Un TAD se compone de estructuras de datos y los procedimientos o

funciones que manipulan esas estructuras de datos.

TAD = Representación (datos) + Operaciones (funciones y procedimientos)

La estructura de un tipo abstracto de dato (clase), desde un punto de

vista global, se compone del interfaz publico y de la implementacion.

Implementación privada

Interfaz público

Método 1

Método 3

Método 2

Método 4

Representación: Estructuras de datos (variables de instancia)

Implementación de métodos:

Código del método 1




Figura. Estructura de un TAD



1.5.1 Ventajas de los tipos abstractos de datos

1. Permite una mejor conceptualizacion y modelado del mundo real.

2. Mejora la robustez del sistema.

3. Mejora el rendimiento.

4. Separa la implementación de la especificación.

5. Permite la extensibilidad del sistema.

1.5.2 Abstracción de datos y TAD

La abstracción define el dominio y estructura de los datos, junto con una

colección o conjunto de operaciones que acceden a los datos.

La idea fundamental de la abstracción de datos conduce a la separación

de la especificación de una estructura de datos (lo que hace) de la

implementación (como lo hace). Esta idea se representa en el tipo

abstracto de dato.



Formato de un TAD

Una descripción de un TAD incluye una cabecera con el nombre del TAD, una

descripción del tipo de datos y una lista de operaciones

TAD Nombre_TAD es

Datos

Describir la estructura de los datos.

Operaciones

Constructor

Valores iniciales: Datos utilizados para iniciar objeto

Proceso : Iniciar el objeto

Operación

Entrada : Datos del cliente

Precondiciones : Estado necesario del sistema antes

de ejecutar la acción

Salida : Acciones ejecutadas con los datos

Postcondiciones : Estado del sistema después de

ejecutar la operación.

Operación2

... ...

Operación3

... ...

Fin TAD Nombre_TAD


Ejemplo de TAD

Describir el TAD Circulo (conjunto de puntos equidistante de un punto llamado

centro). Incluye operaciones de calcular la longitud de la circunferencia y el área

del círculo.

TAD Circulo es

Datos

Numero real no negativo que especifica radio de circulo

Operaciones

Constructor

Valores iniciales: El radio del círculo

Proceso : Asigna valor inicial al circulo

Area

Entrada : Ninguna

Precondiciones : Ninguna

Proceso : Calculo del área del circulo

Salida : Devuelve el área

Postcondiciones : Ninguna

Circunferencia

Entrada : Ninguna

Precondiciones : Ninguna

Proceso : Calcular la circunferencia

Salida : Devuelve la circunferencia

Postcondiciones : Ninguna

Fin TAD Circulo


1.3 IMPLEMENTACION DE TIPOS ABSTRACTOS DE

DATOS EN C

TAD Números complejos. Ejemplo TAD complejo

NUMEROS COMPLEJOS

Son aquellos elementos del sistema los cuales se representan mediante:

Z = a + bi o Z = (a, b)

El conjunto cumple con todos los axiomas de R con excepción de la relación de

orden.

Donde:

a : Es la componente real

b : Es la componente imaginaria

i : Es la unidad imaginaria establecida por:

Z : Es la variable compleja

a + bi : Es el numero complejo

(a, b) : Es el numero o par complejo

11 2 ii



Ejemplo: Z = 3 + 17i = (3, 17) es un numero complejo

Definiciones:

(1o) Si: Z = a + bi es un numero complejo

Z = a – bi es el complejo conjugado

Z* = - a – bi es el complejo opuesto

(2o) Igualdad de números complejos

si: a + bi = m + ni a = m y b = n

(3o) Nulidad de números complejos

si: a + bi = 0 a = 0 y b = 0

Potencias de i

mmkkk iiiiigeneralEn

i

ii

i

ii

41144

4

3

2

1

;,1:

1

1



Algebra de los números complejos:

Se realizan mediante los axiomas del conjunto R

Ejemplo:

Adición: (2+15i) + (3+8i) = (2+3) + (15+8)i = 5 + 23i

Sustracción: (5+7i) – (9+2i) = (5 – 9) + (7 – 2)i = -4 + 5i

Multiplicación: (4+3i) (2+11i) = 8 + 44i + 6i + 33i = 8 + 50i – 33 = -25 + 50i

División:

22

10

11

10

17

9

515412

33

354

3

542

2 i

i

iii

ii

ii

i

i

Para dividir expresiones complejas, se expresa el cociente en forma de fracción

y se racionaliza el denominador de esta fracción, multiplicando ambos términos

de la fracción por la conjugada del denominador.

Si Z = a + bi es un numero complejo

Z = a – bi es el complejo conjugado




DATOS EN C++

En C++ la herramienta de abstracción de datos que permite la creacion de

nuevos tipos se denomina clase (class). Una clase es un tipo de dato que

incluye datos y operaciones que manipulan esos datos. La clase es la entidad

principal de los lenguajes de programación orientados a objetos.

Ejemplo: Clase complejo



//Archivo: complejo.h

#ifndef COMPLEJO

#define COMPLEJO

class complejo{

private:

float r, i;

public:

complejo nuevo_complejo(float x, float y);

float real(complejo c);

float imag(complejo c);

complejo sumar(complejo a, complejo b);

};

#endif


//archivo: complejo.cpp

#include "complejo.h"

complejo complejo::nuevo_complejo(float x, float y)

{

complejo c;

c.r = x;

c.i = y;

return c;

}

float complejo::real(complejo c)

{

return c.r;

}

float complejo::imag(complejo c)

{

return c.i;

}


complejo complejo::sumar(complejo a, complejo b)

{

complejo c;

c.r = a.r + b.r;

c.i = a.i + b.i;

return c;

}


//Archivo: Prueba.cpp

#include <iostream>

#include "complejo.h“

using namespace std;

void main()

{

complejo x, y, z;

float a, b, c, d;

x = x.nuevo_complejo(a, b);

y = y.nuevo_complejo(c, d);

cout << "x= “ << “(“ << x.real(x) <<“,” << x.imag(x) << “)” <<

endl;

cout << “y= “ << “(“ << y.real(y) <<“,” << y.imag(y) << “)” <<

endl;

z = z.sumar(x, y);

cout << "x+y= “ << “(“ << z.real(z) <<“,” << z.imag(z) << “)”

<< endl;

}


/*Tipo Abstracto de Datos en C*/

/*archivo: complejo.h*/

#ifndef COMPLEJO

#define COMPLEJO

typedef struct{

float r, i;

}complejo;





#endif


/*archivo: complejo.c*/


complejo nuevo_complejo(float x, float y)

{

complejo c;

c.r = x;

c.i = y;

return c;

}

float real(complejo c)

{

return c.r;

}

float imag(complejo c)

{

return c.i;

}


complejo sumar(complejo a, complejo b)

{

complejo c;

c.r = a.r + b.r;

c.i = a.i + b.i;

return c;

}

complejo restar(complejo a, complejo b)

{

complejo c;

c.r = a.r - b.r;

c.i = a.i - b.i;

return c;

}

int igual(complejo a, complejo b)

{

return (a.r == b.r && a.i == b.i);

}


complejo multiplicar(complejo a, complejo b)

{

complejo c;

c.r = a.r * b.r - a.i * b.i;

c.i = a.r * b.i + a.i * b.r;

return c;

}

complejo dividir(complejo a, complejo b)

{

complejo c;

float denom = b.r * b.r + b.i * b.i;

c.r = (a.r * b.r + a.i * b.i)/denom;

c.i = (a.i * b.r - a.r * b.i)/denom;

return c;

}


/*archivo: prueba.c*/

#include <stdio.h>


void main()

{

complejo x, y, z;

x = nuevo_complejo(2, 3);

y = nuevo_complejo(4, 5);

printf("x = (%f, %f)\n", real(x), imag(x));

printf("y = (%f, %f)\n", real(y), imag(y));

z = sumar(x, y);

printf("(x + y) = (%f, %f)\n", real(z), imag(z));

}



DATOS EN JAVA

//Archivo Complejo.java

public class Complejo{

private double r, i;

Complejo(double x, double y)

{

r = x;

i = y;

}

public double real() {

return r;

}

public double imag(){

return i;

}


public static Complejo suma(Complejo x, Complejo y)

{

Complejo temp = new Complejo(0, 0);

temp.r = x.r + y.r;

temp.i = x.i + y.i;

return temp;

}

}


//Archivo: Prueba.java

public class Prueba {

public static void main(String args[])

{

Complejo a = new Complejo(40,56);

Complejo b = new Complejo(10,12);

Complejo c = new Complejo(0, 0);

c = Complejo.suma(a, b);

System.out.println("a + b = (" + c.real() + " ," + c.imag() + ")");

}

}


#ifndef COMPLEJO2

#define COMPLEJO2

class complejo{

private:

float r, i;

public:





complejo restar(complejo a, complejo b);

complejo multiplicar(complejo a, complejo b);

complejo dividir(complejo a, complejo b);

};

#endif


//archivo: complejo2.cpp

#include "complejo2.h"

complejo complejo::nuevo_complejo(float x, float y)

{

complejo c;

c.r = x;

c.i = y;

return c;

}

float complejo::real(complejo c)

{

return c.r;

}

float complejo::imag(complejo c)

{

return c.i;

}


complejo complejo::sumar(complejo a, complejo b)

{

complejo c;

c.r = a.r + b.r;

c.i = a.i + b.i;

return c;

}

complejo complejo::restar(complejo a, complejo b)

{

complejo c;

c.r = a.r - b.r;

c.i = a.i - b.i;

return c;

}


complejo complejo::multiplicar(complejo a, complejo b)

{

complejo c;

c.r = a.r * b.r - a.i * b.i;

c.i = a.r * b.i + a.i * b.r;

return c;

}

complejo complejo::dividir(complejo a, complejo b)

{

complejo c;

float denom = b.r * b.r + b.i * b.i;

c.r = (a.r * b.r + a.i * b.i) / denom;

c.i = (a.i * b.r - a.r * b.i) / denom;

return c;

}


#include "complejo2.h"

#include <iostream>

using namespace std;

void main()

{

complejo x, y, z;

/*float a, b, c, d;

cout << "Ingrese el primer numero complejo: ";

cin >> a >> b;

cout << "Ingrese el segundo numero complejo: ";

cin >> c >> d; */

x = x.nuevo_complejo(6, 2);

y = y.nuevo_complejo(8, 3);

cout << "x= " << "(" << x.real(x) <<"," << x.imag(x) << ")" << endl;

cout << "y= " << "(" << y.real(y) <<"," << y.imag(y) << ")" << endl;

z = z.multiplicar(z.sumar(x, y), x);

cout << "(x+y)*x = " << "(" << z.real(z) <<"," << z.imag(z) << ")" << endl;

}

Metodologia de La Programacion Cap 1

Documents

Transcript of Metodologia de La Programacion Cap 1