TADs – Secuencias

Ing. Oscar Danilo Martínez Bernal, M.Sc.

CONTENIDO

TADs

Diseño de TADs

Implementación de TADs

Secuencias

Programación Genérica

STL

Referencias
2
 PARA RECORDAR

● Entrega 0 del proyecto:

● Martes 1 de agosto ANTES DE LA MEDIA NOCHE

3
 TAD

TAD: Tipo Abstracto de Dato.

–Nuevo tipo de dato bien especificado (propio).

–Amplía el lenguaje de programación.

• Consta de:
–Datos (representación):

invisibles al usuario (protegidos o privados).

–Funciones y procedimientos (operaciones):
encapsulados dentro del TAD, acceso por interfaz.
4
 TAD (2)

TAD: Tipo Abstracto de Dato.

–Nuevo tipo de dato bien especificado (propio).

–Amplía el lenguaje de programación.

● Definición:
–Especificación (¿qué hace el TAD?)

–General, global. Formal, matemática.

–Implementación (¿cómo lo hace el TAD?)
–Dependiente del lenguaje a usar.
5
 TAD (3)

Ventajas:
● Mejor conceptualización y modelización.

● Mejora la robustez.

● Mejora el rendimiento (optimización del tiempo de compilación).

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

● Permite extensibilidad.

6
 TAD (4)

http://es.wikipedia.org/wiki/Unión_de_conjuntos
Ejemplos:
● TAD Conjunto

● TAD Carrera

● TAD Biblioteca

● TAD Vehículo

7
https://co.pinterest.com/pin/532832199639015903/
DISEÑO DE TADs

Programas = Algoritmos + Datos

(ecuación de Wirth).
https://web.archive.org/web/20130207170133/http://ww
w.inf.ethz.ch/personal/wirth/books/AlgorithmE0/

● Diseño de TADs:
– Comportamientos del objeto en el mundo real
(interfaz/verbos).
– Conjunto mínimo de datos que lo representan
(estado/sustantivos).
– TAD = Interfaz + Estado.
8
 DISEÑO DE TADs (2)

Plantilla base para diseño de TADs:

● TAD nombre

● Conjunto mínimo de datos:

nombre valor (variable), tipo de dato, descripción

...
● Comportamiento (operaciones) del objeto:

nombre operación (argumentos), descripción funcional

...

9
 DISEÑO DE TADs (3)

EJEMPLO
● TAD Carrera

● Conjunto mínimo de datos:

- nombre, cadena de caracteres, identificación de la carrera

- numEst, número entero, cantidad de estudiantes inscritos
● Comportamiento (operaciones) del objeto:

ObtenerNombre(), retorna el nombre de la carrera

ObtenerNumEst(), retorna la cantidad de estudiantes de la carrera
FijarNombre(nuevoNom), modifica el nombre actual de la carrera
AgregarEstud(), incrementa en uno el conteo de estudiantes
EliminarEstud(), decrementa en uno el conteo de estudiantes
10
 DISEÑO DE TADs (3)

Diagrama de relación entre TADs:

TAD 1 TAD 2

dato1 dato1
dato2 dato2

operacion1 operacion1
operacion2 operacion2
operacion3

TAD 3

dato1
¡Atención! dato2
¡No es un diagrama operacion1
de clases!
11
 IMPLEMENTACIÓN DE TADs (1)

Diferentes posibilidades:
–Estructura con datos y funciones propias o adicionales.

–Clase con niveles de acceso.

Utilizando librerías:
–En el archivo de cabecera (.h) se realiza la declaración de los datos y
los prototipos.
–Enel archivo de implementación (.cpp ó .cxx) se desarrolla la
implementación de las operaciones.

12
 IMPLEMENTACIÓN DE TADs (2)

Librería, se necesitan 2 archivos por TAD:

● - Encabezado (.h):

● Incluye la definición del TAD, en términos de datos y

prototipos de operaciones.
● - Implementación (.cpp ó .cxx):

● Incluye la implementación específica de las operaciones

del TAD.

#include “TAD.h” (al principio del archivo)

13
 IMPLEMENTACIÓN DE TADs (3)

● Opción 1: datos en estructura, operaciones como funciones

adicionales.
struct Carrera{
std::string nombre;
unsigned long numEst;
};

std::string ObtenerNombre(Carrera *c);

unsigned long ObtenerNumEst(Carrera *c);
void FijarNombre(Carrera *c, std::string nombre);
void AgregarEstud(Carrera *c);
void EliminarEstud(Carrera *c);

14
 IMPLEMENTACIÓN DE TADs (4)

● Opción 2: datos y operaciones en estructura.

struct Carrera{
std::string nombre;
unsigned long numEst;

std::string ObtenerNombre();
unsigned long ObtenerNumEst();
void FijarNombre(std::string nombre);
void AgregarEstud();
void EliminarEstud();
};

15
 IMPLEMENTACIÓN DE TADs (5)

● Opción 3: datos y operaciones dentro de una clase de C++.

class Carrera {
public:
Carrera();
std::string ObtenerNombre();
unsigned long ObtenerNumEst();
void FijarNombre(std::string name);
void AgregarEstud();
void EliminarEstud();
protected:
std::string nombre;
unsigned long numEst;
};
16
 IMPLEMENTACIÓN DE TADs (6)

● Para la opción 3, la sintaxis básica en encabezado se divide en 2

regiones claras:

–Públicas(public):
Todas las operaciones del TAD.
Dan acceso a los datos (atributos) del TAD + el constructor.

–Protegidas (protected) o Privadas (private):

Todos los datos (atributos) del TAD

17
 IMPLEMENTACIÓN DE TADs (7)

PASOS PARA IMPLEMENTAR TADs

1. Diseñar el TAD:
descripción + diagrama.

2. Escribir el archivo de encabezado (.h):

un archivo por TAD.

3. Escribir el archivo de implementación (.cxx, .cpp):

un archivo por TAD.

4. Escribir el archivo de programa (.cxx, .cpp):

programa con procedimiento principal,
incluye el encabezado de cada TAD a utilizar. 18
 IMPLEMENTACIÓN DE TADs (8)

OJO:
● El diseño e implementación descrito anteriormente será
exigido en todas las actividades del curso (talleres, parciales,
proyecto, quices) de aquí en adelante, durante todo el
semestre.

19
 SECUENCIAS

Una secuencia es una estructura que representa una lista de elementos

del mismo tipo.
● Formalmente:

𝑆 = 𝑠𝑖 ∈ 𝑇: 1 ≤ 𝑖 ≤ 𝑛, 𝑖 ∈ ℕ

𝑆 = 𝑠1 , 𝑠2 , 𝑠3 , … , 𝑠𝑛

● Ejemplo: secuencia de los números de Fibonacci

1 1 2 3 5 8 13 ...
S0 S1 S2 S3 S4 S5 S6 ...
20
 SECUENCIAS (2)

Conceptos relevantes:

anterior
primero
S0 S1 S2 S3 S4 S5 S6 S7
último
siguiente
posición
índice

21
 SECUENCIAS (3)

Conceptos relevantes:
Secuencia 1
S0 S1 S2 S3 S4 S5 S6 S7

Secuencia 2 ≠ Secuencia 1
S1 S3 S6 S0 S2 S5 S7 S4

22
 SECUENCIAS (4)

¿Cómo implementarlas?
● Arreglo estático: tamaño fijo

int miArr[8] = {1,1,2,3,5,8,13,21};

1 1 2 3 5 8 13 21

string miStr = “palabras”;

p a l a b r a s

23
 SECUENCIAS (5)

¿Cómo implementarlas?
● Arreglo estático: tamaño fijo

Problema: limitado a la capacidad predefinida

1 1 2 3 5 8 13 21 34

int miArr2[9];
for (int i = 0; i < 8; i++)
miArr2[i] = miArr[i];
miArr2[8] = 34;
24
 SECUENCIAS (6)

¿Cómo implementarlas?
● Arreglo por memoria dinámica: tamaño variable

int *miArr = new int[n];

for (int i = 0; i < n; i++)
*(miArr+i) = i+1;
n = 8
1 2 3 4 5 6 7 8
n = 5
1 2 3 4 5
25
 SECUENCIAS (7)

¿Cómo implementarlas?
● Arreglo por memoria dinámica: tamaño variable

Problema: limitado a la capacidad con que se crea

1 2 3 4 5 6 7 8 9

int *miArr2 = new int[9];

for (int i = 0; i < 8; i++)
*(miArr2+i) = *(miArr+i);
*(miArr2+8) = 9;
delete[] miArr; 26
 SECUENCIAS (8)

¿Cómo implementarlas?
Necesidad:
- estructura totalmente dinámica, que ajuste su tamaño en

tiempo de ejecución

- estructura flexible, que acepte diferentes tipos de datos (no

mezclados)

Continuará….
27
PROGRAMACIÓN GENÉRICA
(PLANTILLAS)

a = b + c;
En C++, ¿qué problemas tiene la línea anterior?

28
PROGRAMACIÓN GENÉRICA
(PLANTILLAS) (2)
int b = 5;
int c = 6;
int a = b + c; SUMA INT

int suma( int a, int b )

{
return( a + b );
}
29
PROGRAMACIÓN GENÉRICA
(PLANTILLAS) (3)
float b = 5.67;
float c = 6.923;
float a = b + c;
SUMA FLOAT

float suma( float a, float b )

{
return( a + b );
}
30
PROGRAMACIÓN GENÉRICA
(PLANTILLAS) (4)
Uso de plantillas:
Generalización → adaptabilidad, flexibilidad.

template< class identificador >

declaracion_funcion;

template< typename identificador >

declaracion_funcion;

31
PROGRAMACIÓN GENÉRICA
(PLANTILLAS) (5)
Plantilla con un tipo de dato:

template< class T >

T suma( T a, T b )
{
return( a + b );
}

int a = suma<int>(5, 7);

double b = suma<double>(6.4, 1.7);
32
PROGRAMACIÓN GENÉRICA
(PLANTILLAS) (6)
Plantilla con dos tipos diferentes de dato
template< class T, class U >
T suma( T a, U b )
{
return( a + b );
}

int i, j = 25;
long l = 4567;
i = suma<int,long> (j,l);
33
PROGRAMACIÓN GENÉRICA
(PLANTILLAS) (7)
Plantilla para clases template< class T >
class vec_par {
T valores [2];
public:
vec_par (T uno, T dos)
{
valores[0] = uno;
valores[1] = dos;
}
T minimo ();
}; 34
PROGRAMACIÓN GENÉRICA
(PLANTILLAS) (8)
Plantilla para clases

template< class T >

T vec_par<T>::minimo () {
T resultado;
if (valores[0]<valores[1])
resultado = valores[0];
else
resultado = valores[1];
return resultado;
}
35
PROGRAMACIÓN GENÉRICA
(PLANTILLAS) (9)
Plantilla para clases

vec_par<int> obj_i (115,36);

int res;
res = obj_i.minimo();

vec_par<float> obj_f (32.56,76.98);

float res2;
res2 = obj_f.minimo();

36
 PROGRAMACIÓN GENÉRICA
(PLANTILLAS) (10)

Ejercicio:
Utilizando plantillas, implementar un TAD Operación Binaria,
definido por:
- Operando1 (entero, real o caracter).
- Operando2 (entero, real o caracter).
- Operación (caracter, uno de: '+', '-', '*', '/').
Y con la operación:
- EvaluarOperación (OperaciónBinaria): retorna el resultado de
aplicar la operación sobre los operandos.

https://replit.com/@OscarMartinez25/OpBinaria 37
 PROGRAMACIÓN GENÉRICA
(PLANTILLAS) (11)

Ejercicio:
template <class N>
struct OpBinaria {
N op1;
N op2;
char operacion;
N EvaluarOperacion();
};

38
 PROGRAMACIÓN GENÉRICA
(PLANTILLAS) (12)

Ejercicio:
template <class N>
N OpBinaria<N>::EvaluarOperacion() {
N resul;
switch( operacion ) {
case '+': resul = op1 + op2; break;
case '-': resul = op1 – op2; break;
case '*': resul = op1 * op2; break;
case '/': resul = op1 / op2; break;
}
return resul;
}
39
 PROGRAMACIÓN GENÉRICA
(PLANTILLAS) (13)
Organización de las librerías con plantillas:
● Encabezado (.h)

● Implementación (.hxx, ¿por qué no .cxx?)

● ESTOS DOS ARCHIVOS NO SE COMPILAN.

– Se usan en un archivo compilable (.cxx, .cpp) donde

se INSTANCIAN los elementos genéricos.

40
 PROGRAMACIÓN GENÉRICA
(PLANTILLAS) (14)

OJO
● Encabezado o cabecera (.h):
–Incluye al final el archivo de implementación (.hxx).

● Archivo de código (implementación) (.hxx):

–Incluye al principio la cabecera (.h).

• Para usar la librería con plantilla:

- Incluir la cabecera (.h) en un archivo con procedimiento
principal (.cpp, .cxx).

41
STANDARD TEMPLATE LIBRARY (STL)

● ¡Librería con “muchas cosas” genéricas!

● Provee un conjunto de clases comunes, usables con
cualquier tipo de dato y con operaciones elementales.

Tres componentes:
Contenedores (containers).
●

● Algoritmos (algorithms).
● Iteradores (iterators).
www.bogotobogo.com/cplusplus/stl_vector_list.php

http://www.sgi.com/tech/stl 42
 STANDARD TEMPLATE LIBRARY (STL) (2)

Componentes:
● Contenedores: clases predefinidas para almacenamiento de

datos.

● Algoritmos: operaciones básicas como búsqueda y

ordenamiento.

● Iteradores: permiten recorrer los datos en los contenedores

(similar a apuntadores).

http://www.sgi.com/tech/stl 43
STANDARD TEMPLATE LIBRARY (STL) (3)

¿Cómo se conectan estos conceptos?

www.bogotobogo.com/cplusplus/stl3_iterators.php

http://www.sgi.com/tech/stl 44
 TAREA

Revisar la STL e identificar:

- ¿Cuáles contenedores provee?
- ¿Qué diferencias hay entre ellos?

45
REFERENCIAS

● T.H. Cormen, C.E. Leiserson, R.L. Rivest, C. Stein.

Introduction to Algorithms, 3rd edition. MIT Press,
2009.
● L. Joyanes Aguilar, I. Zahonero. Algoritmos y
estructuras de datos: una perspectiva en C. McGraw-
Hill, 2004.

46