Prog Modular y Tda

Lenguajes y Ciencias de la Computación Universidad de Málaga
UNIVERSIDAD DE MÁLAGA
Dpto. Lenguajes y CC. Computación
E.T.S.I. Telecomunicación
TIPOS ABSTRACTOS DE DATOS
Tema 2
Programación II
Programación II 0 Tema 2: TIPOS ABSTRACTOS DE DATOS

Tema 2: TIPOS ABSTRACTOS DE DATOS

' $
1. Programación Modular
& %
2. Tipos Abstractos de Datos
3. Subprogramas Genéricos
4. Tipos Abstractos de Datos Genéricos
5. Ejemplo: TAD Lista Genérica
6. Bibliografı́a

PROGRAMACIÓN MODULAR
La división del código fuente en modulos presenta numerosas ven-

tajas:
• Aumenta la localidad, cohesión y aislamiento del código

◦ Facilita la corrección de errores, la abstracción y modificación del código
• Proporciona compilación separada de módulos
• Fundamental para la reutilización de código.

◦ Posibilita la creación, distribución y utilización de bibliotecas
M1 Main M2 Programa
GUI Math MP3 JPG Bbl. Utilidades
Mem File I/O Proc Sckts API S.O.
Kernel S.O. S.O.

INTERFAZ, IMPLEMENTACIÓN Y UTILIZACIÓN DE MÓDULOS

Usualmente, en C++, un módulo de se compone de dos ficheros:
• Interfaz (público): contiene las definiciones de tipos, constantes y prototipos

de los subprogramas que el módulo ofrece (guardas previenen inclusión duplicada)
• Implementación (privado): código que resuelve un determinado problema.

Implementa los subprogramas que el módulo ofrece
Un programa completo se compone de varios módulos, cada uno con su fichero

de interfaz y de implementación, y de un módulo principal donde reside la función
principal main.
• El fichero de implementación deberá incluir el fichero de encabezamiento

(interfaz) para acceder a las definiciones ("...")
• Para utilizar las facilidades que proporciona un módulo, se deberá incluir el

fichero de encabezamiento (interfaz) del módulo que vaya a utilizar ("...")
main.cpp (Principal) complejo.hpp (Interfaz) complejo.cpp (Implementación)

#include "complejo.hpp" #ifndef complejo hpp #include "complejo.hpp"
int main() #define complejo hpp // Constantes Auxiliares
{ // Constantes // Tipos Auxiliares
// Utilización // Tipos // Subprogramas Auxiliares
// de Complejo // Prototipos // Subprogramas Exporta
} #endif ···

COMPILACIÓN SEPARADA Y ENLAZADO

complejo.hpp mat.hpp iostream string
Interfaz +
Interfaz Implementación Interfaz Interfaz
Público Público Público Público
C.Fuente C++ C.Fuente C++ C.Fuente C++ C.Fuente C++
complejo.cpp main.cpp bblstd.cpp
Implementación Programa Implementación

Privado Principal Privado
C.Fuente C++ C.Fuente C++ C.Fuente C++
Compilación Compilación Compilación
complejo.o main.o bblstd.o Enlazado main
Implementación Programa Implementación Programa

Público Principal Público Completo
C.Objeto C.Objeto C.Objeto C.Ejecutable
Generación del programa ejecutable: dos procesos

• Compilación separada:
g++ -ansi -Wall -Werror -c complejo.cpp
g++ -ansi -Wall -Werror -c main.cpp
• Enlazado: g++ -ansi -Wall -Werror -o main main.o complejo.o
• Es posible realizar ambos procesos al mismo tiempo:

g++ -ansi -Wall -Werror -o main main.cpp complejo.cpp
• Es posible combinar ambos procesos:

g++ -ansi -Wall -Werror -o main main.cpp complejo.o
• Es posible enlazar con bibliotecas externas:

g++ -ansi -Wall -Werror -o main main.cpp complejo.cpp -ljpeg

ESPACIOS DE NOMBRE: DEFINICIÓN
Para evitar posibles colisiones entre identificadores pertenencientes a distintos

módulos existen los espacios de nombre (namespace)
Permiten agrupar bajo una misma denominación un conjunto de declaraciones

y definiciones
Esta denominación será necesaria para identificar y diferenciar cada entidad

declarada en un determinado espacio de nombres
La inclusión de ficheros fuera del espacio de nombres
Espacio de nombres Anónimo, para la implementación privada de entidades auxi-

liares en el módulo de implementación
main.cpp (Principal) complejo.hpp (Interfaz) complejo.cpp (Implementación)
#include <iostream> #ifndef complejo hpp #include "complejo.hpp"
#include "complejo.hpp" #define complejo hpp #include <...otros...>
using namespace std ; #include <...otros...> namespace umalcc {
using namespace umalcc ; namespace umalcc { // Constantes Auxiliares
int main() // Constantes // Tipos Auxiliares
{ // Tipos // Subprogramas Auxiliares
// Utilización // Prototipos // Subprogramas Exporta
// de Complejo } ···
} #endif }

ESPACIOS DE NOMBRE: UTILIZACIÓN
Para utilizar un determinado identificador definido dentro de un espacio de nom-

bres es necesario algún tipo de cualificación
• Desde dentro del mismo espacio de nombres no es necesario utilizar ningún
tipo de cualificación
• En un fichero de implementación (cpp), la directiva using namespace permite
utilizar todos los identificadores del espacio de nombre sin necesidad de cua-
lificación (cualificación implı́cita)
• En un fichero de interfaz (hpp), se debe utilizar la cualificación explı́cita
(::) para referenciar a cualquier identificador perteneciente a otro espacio
de nombres
main.cpp (Principal) datos.hpp (Interfaz)

#include <iostream> #ifndef datos hpp
#include <string> #define datos hpp
#include "datos.hpp" #include <string>
using namespace std ; #include <tr1/array>
using namespace umalcc ; #include <...otros...>
int main() namespace umalcc {
{ typedef std::tr1::array<int, 9> Vector ;
string nombre ; void leer(std::string& nm, Vector& v) ;
Vector v ; }
} #endif

ESPACIOS DE NOMBRE: COLISIONES
Cuando se utilizan varios espacios de nombre de forma implı́cita,

pueden suceder colisiones de identificadores definidos en ambos
espacios de nombre
• En este caso, se puede utilizar la cualificación explı́cita para

deshacer la ambigüedad
main.cpp (Principal) datos.hpp (Interfaz)
#include <iostream> #ifndef datos hpp
#include <string> #define datos hpp
#include "datos.hpp" #include <tr1/array>
using namespace std ; #include <...otros...>
using namespace umalcc ; namespace umalcc {
int main() struct string {
{ std::tr1::array<char, 50> datos ;
string colision ; int size ;
std::string nombre 1 ; } ;
umalcc::string nombre 2 ; ···
··· }
} #endif

PROGRAMACIÓN MODULAR. EJEMPLO
//- fichero: complejos.hpp -------------

#ifndef _complejos_hpp_
#define _complejos_hpp_
namespace umalcc {
struct Complejo {
double real ;
double imag ; //- fichero: main.cpp ------------------
} ; #include <iostream>
void sumar(Complejo& r, const Complejo& a, #include "complejos.hpp"
const Complejo& b) ; using namespace std ;
} using namespace umalcc ;
#endif int main()
{
//- fichero: complejos.cpp ------------- Complejo c1 = { 3.4, 5.6 } ;
#include "complejos.hpp" Complejo c2 = { 1.3, 7.2 } ;
#include <iostream> Complejo c3 ;
using namespace std ; sumar(c3, c1, c2) ;
namespace umalcc { cout << c3.real << " " << c3.imag << endl ;
void sumar(Complejo& r, const Complejo& a, }
const Complejo& b) //- fin: main.cpp ----------------------
{
r.real = a.real + b.real ;
r.imag = a.imag + b.imag ;
}
}
//- fin: complejos.cpp -----------------

' $

& %
6. Bibliografı́a

TIPOS ABSTRACTOS DE DATOS (TAD)
Complejidad del problema a resolver
⇒ Complejidad Algorı́tmica: Abstracción Procedimental/Modular
⇒ Complejidad Estructuras de Datos: Tipos Abstractos de Datos
Tipo Abstracto de Datos (TAD): TAD

op1()
• Especifica el concepto abstracto que representa op2()
op3()
• Especifica la semántica de las operaciones
• Representación e implementación inaccesibles
• Utilización independiente de la implementación

TIPOS ABSTRACTOS DE DATOS (TAD)
Un tipo abstracto de datos encapsula una determinada estructura

abstracta de datos TAD
op1()
op2()
• Impide su manipulación directa
op3()
• Permite solamente su manipulación a través de las operaciones especificadas
• Proporciona un mecanismo adecuado para el diseño y reutilización de soft-

ware fiable y robusto.
Utilización de TAD
Especificación de TAD
Para un TAD, se distinguen tres niveles: Implementación de TAD
• Utilización: basada en la especificación, independiente de su implementación.
Manipulación mediante la invocación a operaciones públicas.
• Especificación: (interfaz público) especifica el concepto abstracto que rep-

resenta, y la semántica y restricciones de las operaciones.
• Implementación: (privada) define las estructuras de datos internas y la im-

plementación de las operaciones.

DEFINICIÓN DE TAD en C++: CLASES Y OBJETOS

Las clases en C++ proporcionan un soporte adecuado a la uti-
lización, definición, e implementación de tipos abstractos de datos
Las clases permiten definir la representación interna (atributos) y

las operaciones (métodos) que definen el TAD, ası́ como su uti-
lización
Una clase define un TAD, y un objeto es una instancia de una clase

(de igual forma que una variable es una instancia de un tipo de datos)
Definiremos las clases utilizando programación modular:

• Definición de la clase en el fichero interfaz del módulo (hpp)
• Implementación de la clase en el fichero de implementación del módulo (cpp)
• Utilización de la clase de igual forma que la utilización de módulos.

DEFINICIÓN DE CLASES
//- fichero: complejos.hpp -------------
#ifndef _complejos_hpp_
#define _complejos_hpp_
namespace umalcc {
Definición de clase en fichero hpp,
con guarda y espacio de nombre class Complejo {
class Nombre { ... } ; public: // zona pública
Complejo() ; // CTOR por Defecto

Dos ámbitos de accesibilidad:
public y private void sumar(const Complejo& a,
const Complejo& b) ;
Atributos: representación interna void leer() ;

(instancias independientes para cada objeto)
void escribir() const ;
Constructor por defecto private: // zona privada
(construye e inicializa un objeto)
double real ; // ATRIBUTO
Métodos y métodos constantes
double imag ; // ATRIBUTO
(operaciones que manipulan el objeto)
} ;
}
#endif
//- fin: complejos.hpp -----------------

UTILIZACIÓN: OBJETOS COMO INSTANCIAS DE CLASES
//- fichero: main.cpp ------------------

#include <iostream>
Incluir hpp y uso de espacio de nombre #include "complejos.hpp"
using namespace std ;
5.3
Objeto como instancia de una clase using namespace umalcc ;
2.4
(propia representación interna independiente)
int main() c1
{
Tiempo de vida: Complejo c1, c2, c3 ;
2.5
construcción y destrucción 7.3
c1.leer() ;
c2
Invocación a métodos: el operador punto c2.leer() ;
(aplicación a objeto concreto)
c3.sumar(c1, c2) ; 7.8
9.7
Paso de parámetros por referencia
c3.escribir() ; c3
(normal o constante) }
//- fin: main.cpp ----------------------

IMPLEMENTACIÓN DE CLASES
//- fichero: complejos.cpp -------------
Implementación en fichero cpp, dentro #include "complejos.hpp"
del mismo espacio de nombre #include <iostream>
namespace umalcc {
Definición e implementación de
constantes, tipos y subprogramas auxiliares Complejo::Complejo()
: real(0.0), imag(0.0) { }
Implementación de Constructores y void Complejo::sumar(const Complejo& a,

Métodos de clase: const Complejo& b)
cualificación explı́cita con ident. de la clase {
real = a.real + b.real ;
imag = a.imag + b.imag ;
Acceso a Atributos e invocación a }
Métodos
void Complejo::escribir() const
• Aplicación directa a objeto con- {
creto (invocación) cout << "{ " << real << ", " << imag << " }" ;
}
• Otros objetos: aplicación del op-
erador punto (.) void Complejo::leer()
{
cin >> real >> imag ;
Constructor: }
lista de inicialización (orden) + cuerpo }
//- fin: complejos.cpp -----------------

MÁS SOBRE DE CLASES

class Complejo {
Constantes y Tipos de ámbito de public:
clase (privados y públicos – notación ::) ~Complejo() ;
Complejo() ;
Complejo(const Complejo& o) ;
Constructores especı́ficos Complejo(double p_real, double p_imag) ;
Complejo& operator=(const Complejo& o) ;
Constructor por defecto private:
static const int MAX = 256 ;
typedef tr1::std::array<int, MAX> Datos ;
Constructor de copia struct Elemento { /* ... */ } ;
};
Complejo::~Complejo() { }
Destructor Complejo::Complejo() : real(), imag() { }
Complejo::Complejo(const Complejo& o)
Operador asignación [ &o this *this ] : real(o.real), imag(o.imag) { }
Complejo::Complejo(double p_real, double p_imag)
int main() : real(p_real), imag(p_imag) { }
{ Complejo& Complejo::operator=(const Complejo& o)
Complejo c1 ; {
Complejo c2(2.5, 7.3) ; // compara direcciones de memoria de los objetos
Complejo c3(c2) ; if (this != &o) {
Complejo c4 = c2 ; // destruir valor anterior y asignar nuevo
c4 = c2; real = o.real ;
c4 = Complejo(2.5, 7.3); imag = o.imag ;
// ... }
} return *this ; // devuelve el propio objeto
}

' $
& %
6. Bibliografı́a

SUBPROGRAMAS GENÉRICOS (I)
Las definiciones genéricas deben estar

visibles en el lugar de su instanciación
template <typename Tipo>
inline void intercambio(Tipo& x, Tipo& y)
Definiciones de subprogramas {
parametrizadas sobre tipos y Tipo aux = x ;
constantes en tiempo de compilación x = y ;
y = aux ;
}
Definen procesamientos genéricos,
aplicables a múltiples tipos de datos int main()
{
Instanciación automática en la invo- int x = 4 ;
int y = maximo(x, 8) ;
cación al subprograma intercambio(x, y) ;
inline Tipo maximo(const Tipo& x, const Tipo& y) double a = 7.5 ;
{ double b = maximo(a, 12.0) ;
Tipo max; intercambio(a, b) ;
if (x > y) {
max = x ; double c = maximo(a, 12) ; // ERROR
} else {
max = y ; double d = maximo<double>(a, 12) ;
} }
return max ;
}
SUBPROGRAMAS GENÉRICOS (II)
typedef array<int, 5> AInt ;

#include <iostream>
void prueba1()
#include <string>
{
#include <tr1/array>
AInt a = {{ 1, 2, 3, 4, 5 }};
escribir(a);
using namespace std::tr1 ;
asignar(a, 5) ;
//-------------------------------------
escribir(a);
template <typename TipoBase, unsigned SIZE>
}
void asignar(array<TipoBase, SIZE>& v,
typedef array<string, 3> APers ;
const TipoBase& x)
void prueba2()
{
{
for (int i = 0 ; i < int(v.size()) ; ++i) {
APers a = {{ "pepe", "juan", "marı́a" }} ;
v[i] = x ;
escribir(a);
}
asignar(a, "lola") ;
}
escribir(a);
//-------------------------------------
}
// Requiere que << se pueda aplicar a TipoBase
struct Persona {
template <typename TipoBase, unsigned SIZE>
string nombre ;
void escribir(const array<TipoBase, SIZE>& v)
string telefono ;
{
} ;
for (int i = 0 ; i < int(v.size()) ; ++i) {
typedef array<Persona, 2> APersona ;
cout << v[i] << " ";
void prueba3()
}
{
cout << endl ;
APersona a = {{ { "pp", "00" }, { "jj", "11" } }} ;
}
escribir(a); // ERROR
//-------------------------------------
}

' $

& %
6. Bibliografı́a

TIPOS ABSTRACTOS DE DATOS GENÉRICOS

Las definiciones genéricas deben estar
visibles en el lugar de su instanciación
//-- fichero: dato.hpp -----------------
#ifndef _dato_hpp_
Definición e implementación (“en- #define _dato_hpp_
lı́nea”) en el fichero de interfaz (hpp) namespace umalcc {
class Dato {
Definiciones de clases parametrizadas public:
sobre tipos y constantes en t. compil. Dato() : dat() { }
Dato(const Tipo& x) : dat(x) { }
void asignar(const Tipo& x)
Definen TADs genéricos, aplicables a
{
múltiples tipos de datos dat = x;
}
Requiere instanciación explı́cita Tipo acceder() const
{
#include <iostream> return dat;
#include "dato.hpp" }
using namespace std ; private:
using namespace umalcc ; Tipo dat;
int main() };
{ }
Dato<int> x ; #endif
x.asignar(3) ; //-- fin: dato.hpp ----------------------
cout << x.acceder() << endl ;
}

' $

& %
6. Bibliografı́a

EJEMPLO: TAD LISTA GENÉRICA

Diseñe un TAD lista genérica posicional que contiene una secuencia de elementos
homogéneos (de tipo genérico, con una capacidad máxima genérica) accesibles
por su posición, que defina los siguientes métodos:
• Destructor: destruye y libera los recursos asociados a la lista
• Constructor por defecto: construye una lista vacı́a
• Constructor de copia: copia el contenido de otra lista
• Operador de asignación: asigna el contenido de otra lista
• Llena: método constante que devuelve si el número de elementos almacenados en la lista

alcanzó su máxima capacidad
• Size: método constante que devuelve el número de elementos almacenados en la lista
• Clear: elimina los elementos almacenados, dejando la lista vacı́a
• Insertar: inserta el elemento recibido como parámetro en la posición indicada como parámetro
• Eliminar: elimina el elemento que se encuentra en la posición indicada como parámetro
• Acceder: método constante que devuelve el elemento almacenado en la posición indicada

como parámetro
• Modificar: asigna el elemento recibido como parámetro al elemento que se encuentra en la

posición indicada como parámetro


' $
6. Bibliografı́a
& %

Prog Modular y Tda

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Prog Modular y Tda

Cargado por

Copyright:

Formatos disponibles

Lenguajes y Ciencias de la Computación Universidad de Málaga

TIPOS ABSTRACTOS DE DATOS

Programación II 0 Tema 2: TIPOS ABSTRACTOS DE DATOS

Tema 2: TIPOS ABSTRACTOS DE DATOS

2. Tipos Abstractos de Datos

4. Tipos Abstractos de Datos Genéricos

5. Ejemplo: TAD Lista Genérica

Programación II 1 Tema 2: TIPOS ABSTRACTOS DE DATOS

La división del código fuente en modulos presenta numerosas ven-

• Aumenta la localidad, cohesión y aislamiento del código

• Proporciona compilación separada de módulos

• Fundamental para la reutilización de código.

GUI Math MP3 JPG Bbl. Utilidades

Mem File I/O Proc Sckts API S.O.

Kernel S.O. S.O.

Programación II 2 Tema 2: TIPOS ABSTRACTOS DE DATOS

INTERFAZ, IMPLEMENTACIÓN Y UTILIZACIÓN DE MÓDULOS

• Interfaz (público): contiene las definiciones de tipos, constantes y prototipos

• Implementación (privado): código que resuelve un determinado problema.

Un programa completo se compone de varios módulos, cada uno con su fichero

• El fichero de implementación deberá incluir el fichero de encabezamiento

• Para utilizar las facilidades que proporciona un módulo, se deberá incluir el

main.cpp (Principal) complejo.hpp (Interfaz) complejo.cpp (Implementación)

Programación II 3 Tema 2: TIPOS ABSTRACTOS DE DATOS

COMPILACIÓN SEPARADA Y ENLAZADO

complejo.cpp main.cpp bblstd.cpp

Implementación Programa Implementación

Compilación Compilación Compilación

complejo.o main.o bblstd.o Enlazado main

Implementación Programa Implementación Programa

Generación del programa ejecutable: dos procesos

• Enlazado: g++ -ansi -Wall -Werror -o main main.o complejo.o

• Es posible realizar ambos procesos al mismo tiempo:

• Es posible combinar ambos procesos:

• Es posible enlazar con bibliotecas externas:

Programación II 4 Tema 2: TIPOS ABSTRACTOS DE DATOS

ESPACIOS DE NOMBRE: DEFINICIÓN

Para evitar posibles colisiones entre identificadores pertenencientes a distintos

Permiten agrupar bajo una misma denominación un conjunto de declaraciones

Esta denominación será necesaria para identificar y diferenciar cada entidad

La inclusión de ficheros fuera del espacio de nombres

Espacio de nombres Anónimo, para la implementación privada de entidades auxi-

Programación II 5 Tema 2: TIPOS ABSTRACTOS DE DATOS

ESPACIOS DE NOMBRE: UTILIZACIÓN

Para utilizar un determinado identificador definido dentro de un espacio de nom-

main.cpp (Principal) datos.hpp (Interfaz)

Programación II 6 Tema 2: TIPOS ABSTRACTOS DE DATOS

ESPACIOS DE NOMBRE: COLISIONES

Cuando se utilizan varios espacios de nombre de forma implı́cita,

• En este caso, se puede utilizar la cualificación explı́cita para

Programación II 7 Tema 2: TIPOS ABSTRACTOS DE DATOS

PROGRAMACIÓN MODULAR. EJEMPLO

//- fichero: complejos.hpp -------------

Programación II 8 Tema 2: TIPOS ABSTRACTOS DE DATOS

Tema 2: TIPOS ABSTRACTOS DE DATOS

2. Tipos Abstractos de Datos

4. Tipos Abstractos de Datos Genéricos

5. Ejemplo: TAD Lista Genérica

Programación II 9 Tema 2: TIPOS ABSTRACTOS DE DATOS

TIPOS ABSTRACTOS DE DATOS (TAD)

Complejidad del problema a resolver

⇒ Complejidad Algorı́tmica: Abstracción Procedimental/Modular