PROGRAMACION II.

POO MISION SUCRE

PROFESOR: JESUS RAMOS

PROGRAMACION II. POO MISION SUCRE

La programación orientada por objetos (POO)

Es un estilo de programación, basado en el uso de entidades u objetos, los cuales responden a ciertos
estímulos que cambian el estado de los mismos, permitiendo así la interacción entre diversos
objetos.

Qué es un Objeto?
Es una entidad que combina tres aspectos fundamentales, el estado, el comportamiento y la
identidad.
• El estado se refiere a los datos, es decir, uno o varios atributos a los que se habrán asignado
unos valores concretos.
• El comportamiento está definido por los procedimientos o métodos con que puede operar
dicho objeto, es decir, qué operaciones se pueden realizar con él.
• La identidad es una propiedad de un objeto que lo diferencia del resto, dicho con otras
palabras, es su identificador.

Los métodos son los

únicos encargados de
modificar los atributos
del objeto.

Característica de la POO.

Abstracción: Se refiere a las características esenciales de un objeto que permiten generalizar algo.
Cuando se habla de una mujer, se piensa en una persona de sexo femenino, posiblemente con
cabello largo, joven, etc. cuando se habla de un hombre, se piensa igualmente en una persona pero
con características diferentes; en este caso se puede extraer un término que es común para ambos
seres, y es el término Persona, sin tener en cuenta las características que diferencian a una de otra;
ese es el término abstracto.

Encapsulamiento: esto es reunir todos los elementos suficientes y necesarios de una misma entidad,
para logra una mayor cohesión de los componentes del sistema.

Principio de ocultación: Todos los atributos de un objeto son protegidos para que solo puedan ser
accedidos por sus métodos. Con esto se asegura que otros objetos no puedan cambiar el estado
interno de un objeto de maneras inesperadas, eliminando efectos secundarios e interacciones
inesperadas.

PROFESOR: JESUS RAMOS

PROGRAMACION II. POO MISION SUCRE

Polimorfismo: se refiere a comportamientos diferentes, asociados a objetos distintos, pueden

compartir el mismo nombre, al llamarlos por ese nombre se utilizará el comportamiento
correspondiente al objeto que se esté usando. Cuando esto ocurre en "tiempo de ejecución", esta
última característica se llama asignación tardía o asignación dinámica. Algunos lenguajes
proporcionan medios más estáticos (en "tiempo de compilación") de polimorfismo, tales como las
plantillas y la sobrecarga de operadores de C++.

Herencia: los objetos no están aisladas, sino que se relacionan entre sí, formando una jerarquía de
clasificación. Los objetos heredan las propiedades y el comportamiento de todas las clases a las que
pertenecen. La herencia permite la reutilización de código, ya que los objetos de mayor jerarquía
pueden compartir (y extender) su comportamiento sin tener que volver a implementarlo. Esto suele
hacerse habitualmente agrupando los objetos en clases.

En C++, la abstracción y el encapsulamiento esta representado por una clase, la clase es una
abstracción por lo que se definen las propiedades (funciones) y atributos (datos) de un determinado
conjunto de objetos.

class Persona{
//atributos char*
Persona nombre; char*
colorCabello[20]; int
Nombre; colorCabello;
edad; char sexo;

Edad; public:
//métodos
Sexo; int setNombre(char* elNombre, int tam);
char* getNombre();
...
...
}
setNombre();
getNombre();
setColorCabello();
getColorCabello(); setEdad();
getEdad(); setSexo();
getSexo();

El cuerpo de los métodos de la clase, se realiza fuero de la definición de la misma, bajo la siguiente
sintaxis:

<Tipo de retorno> <Nombre de clase>::<Nombre del método>(lista de parámetros){

Cuerpo de la función o método. }

Para el ejemplo tratado se vería de la siguiente forma:

PROFESOR: JESUS RAMOS

PROGRAMACION II. POO MISION SUCRE

int Persona::setNombre(char* elNombre, int

tam){ nombre = new char[tam]; if (nombre
== NULL){
cout << “No hay espacio de memoria.”;
return -1; }
*nombre = *elNombre;
return 0;
} char*

Persona::getNombre(){

return nombre;

Toda clase posee dos (2) tipos de métodos especiales: los constructores y los destructores. El
constructor es llamado por el compilador cada vez que se crea un objeto de ese tipo, dicho de otra
forma, el objeto es instanciado y el destructor es llamado siempre que una instancia de la clase se
destruye.

Generalmente los constructores se utilizan para inicializar los atributos de la clase, y llevan el mismo
nombre y el destructor para vaciar espacios de memoria, tambien lleva el nombre de la clase
precedido del símbolo ~. En nuestro ejemplo se vería como sigue:
class Persona{
//atributos char*
nombre; char*
colorCabello[20]; int
edad; char sexo;

public:
//métodos
Persona(); //Constructor int
setNombre(char* elNombre, int tam);
char* getNombre();
...
...
~Persona(); //Destructor
}

PROFESOR: JESUS RAMOS

PROGRAMACION II. POO MISION SUCRE

Estructura Lineal de Datos

Una estructura lineal de datos o lista está conformada por ninguno, uno o varios elementos que
tienen una relación de adyacencia ordenada donde existe un primer elemento, seguido de un
segundo elemento y así sucesivamente hasta llegar al último. El tipo de dato de los elementos puede
ser cualquiera, pero debe ser el mismo tipo para todos.

Clasificación de las Estructuras Lineales de Datos

Se pueden clasificarse según el criterio o base de la forma y el lugar que se sigue para realizar
sus operaciones básicas (agregar, eliminar elementos, etc). De acuerdo a estos criterios se tiene:

Pilas: las operaciones de acceso se realizan por un único extremo de la

lista (tope de la
pila),
Listas de Acceso
Restringido
Colas: las operaciones se realizan por ambos extremos de
la lista (se inserta por un extremo y se elimina por el otro) .
Entrada Restringida: Se inserta por
De acuerdo al un extremo y se elimina por ambos
Criterio de las
Operaciones
Dipolo: de
inserción y
eliminación Salida Restringida: Se elimina por un
extremo y se inserta por ambos

Listas de Acceso Listas generales: no tienen una restricción no

Restringidoen cuanto a sus operaciones. se considera como
la superclase de las otras clases de listas, en específico de las pilas,
colas y dipolos.

Ascendentes

PROFESOR: JESUS RAMOS

PROGRAMACION II. POO MISION SUCRE

Ordenadas
Descendentes
De acuerdo al orden
de sus elementos
Desordenadas

- Elementos contiguos físicamente en memoria - Se utiliza el

tipo arreglo

- Secuencial
(Simple y - Son estáticas, porque su tamaño esta limitado
Circular) por el tamaño del arreglo.

- Acceso a los elementos en forma directa

De acuerdo al método de almacenamiento

- Enlazado- Manejo Dinámico de la memoria.

(Simple
Simple Circular- Se maneja mediante apuntadores
Doble
Doble Circular)- No tienen tamaño fijo

Representación Lógica

Las listas se representan en forma lógica como una secuencia de elementos.

Ejemplos: Una lista de Estudiantes, una lista de empleados, Una lista de artículos, etc.

En forma gráfica, una lista se representa como:

e1 e2 ... en-2 en-1 en

Estructuras de Almacenamiento para las estructuras lineales de datos

Para almacenar en memoria una lista se utilizan dos métodos: el secuencial y el

enlazado

PROFESOR: JESUS RAMOS

PROGRAMACION II. POO MISION SUCRE

Método Secuencial: Los elementos de la lista están contiguos físicamente en la memoria y para
su soporte se utiliza el tipo Arreglo. Los accesos a los elementos se efectúan en forma directa, por
medio de un índice, siendo el acceso mas rápido, sin embargo, el crecimiento de la mismas esta
sujeto al tamaño máximo del arreglo.

Método de Enlazado: Los elementos en la lista no necesariamente se encuentran contiguos en

la memoria. Las listas, pueden ampliar o limitar su tamaño mientras se ejecuta el programa.

Especificación del Tipo Abstracto de Datos LISTA

Las listas, representan el tipo más general, al cual se considera como la superclase de las otras clases
de listas, en específico de las pilas, colas y dipolos. Haciendo la jerarquía de clases adecuada para
estas estructuras, se tiene que la lista es la clase raíz de la jerarquía que tiene como subclases la pila,
la cola y el dipolo.

Figura No. 1: Jerarquía de Clases para las Listas

Propiedades de las Listas:

Cada elemento de la lista tiene asignado un tipo de dato. Si L representa un tipo de
ListaDe[TipoEle: e] entonces e1, e2, ..., en conforman la lista cuyos elementos tienen asignado un
mismo tipo.
Si n=0 entonces la lista esta vacía

Si n>=1 entonces e1 es el primer elemento de la lista y en el ultimo

ei es el predecesor de ei+1 y el sucesor de ei-1 con 1<=i<=n

Especificación del Tipo Abstracto de Datos LISTA

Especificación Lista[TipoEle]

PROFESOR: JESUS RAMOS

PROGRAMACION II. POO MISION SUCRE

1 Especificación Sintáctica CrearLista() Crea una Lista vacía

CreaLista() Lista, InsLista() Ingresa un nuevo elemento
InsLista() Lista, a la Lista según una posición especifica
EliLista(), Elimina un elemento de la
EliLista() Lista,
Lista según una posición especifica
ConsLista() TipoEle, VaciaLista() Logico, VaciaLista(), Retorna Cierto si la lista
DestruyeLista() . esta vacía
DestruyeLista(): Destruye la Lista
2 Declaraciones ConsLista(), Retorna el elemento de la
TipoEle : e, {TipoEleNoDef} lista según una posición especifica. Si la
3 lista esta vacía devuelve un valor
Especificación Semántica
especial que lo indica.
VaciaLista(CrearLista())=Cierto
VaciaLista(InsLista(CreaLista(),e))=Falso
ConsLista(CrearLista())={TipoEleNoDef}
EliLista(CrearLista())=CrearLista()

Implementación del TAD LISTA según el Método Enlazado Simple

PILAS:
Son un tipo especial de lista, conocidas como listas LIFO (Last In, First Out): el último en entrar es el
primero en salir). Los elementos se "amontonan" o apilan, de modo que sólo el elemento que está
encima de la pila puede ser leído, y sólo pueden añadirse elementos encima de la pila.

COLAS:
Otro tipo de listas, conocidas como listas FIFO (First In, First Out: El primero en entrar es el primero
en salir). Los elementos se almacenan en fila, pero sólo pueden añadirse por un extremo y leerse
por el otro.

LISTAS CIRCULARES:
También llamadas listas cerradas, son parecidas a las listas enlazadas, pero el último elemento
apunta al primero. De hecho, en las listas circulares no puede hablarse de "primero" ni de "último".
Cualquier nodo puede ser el nodo de entrada y salida. Se recorren siempre en el mismo sentido.

LISTAS DOBLEMENTE ENLAZADAS:

Cada elemento dispone de dos punteros, uno apunta al siguiente elemento y el otro al elemento
anterior.
Al contrario que las listas abiertas anteriores, estas listas pueden recorrerse en los dos sentidos.
5

Crear Pila Consultar Tope Pila

PROFESOR: JESUS RAMOS

PROGRAMACION II. POO MISION SUCRE

Estructura de dato Pila

Meter Elemento Pila Sacar Elemento Pila

Vacía Pila Destruye Pila

Especificación Pila[TipoEle]

Especificación Sintáctica CrearPila() Crea una pila vacía InsertaElem()

1 Ingresa un nuevo
CrearPila() Pila, elemento a la pila por el tope de la misma
InsertaElem() Pila, EliminarElem(), Elimina el elemento que
esta actualmente en el tope de la pila, si la
EliminarElem() Pila,
pila no esta vacía
ConsultaPila() TipoEle, VaciaPila(), Retorna Cierto si la pila esta vacía
VaciaPila() Logico, MostrarPila() . DestruyePila(): Destruye la pila
ConsultaPila(), Retorna el elemento
2 DestruyePila()() .
apuntado por l tope de la pila.
Declaraciones MostrarPila(): Imprime en pantalla todos
3 TipoEle : e, {TipoEleNoDef} los elementos de la pila.
Especificación Semántica
VaciaPila(CrearPila())=Cierto
VaciaPila(InsertaElem())=Falso
ConsultaPila(CrearPila())={TipoEleNoDe f}
EliminarElem(CrearPila())=CrearPila()

PROFESOR: JESUS RAMOS

PROGRAMACION II. POO MISION SUCRE

/*******************************
ARCHIVO DE CABECERA pila.h
********************************/
#include <iostream>
#include <cstdlib> using
namespace std; const
int MAXI = 100;

class Pila{
int tope;
int PilaSec[MAXI];

public: Pila(void); void

InsertaElem(int e); void
EliminarElem(); int
ConsultaPila(); int
VaciaPila(); void
MostrarPila();
~Pila(); };
Pila::Pila(){ tope=0; for (int i
=0;i<MAXI; i++){ PilaSec[i]
= 0;
}
}

void Pila::InsertaElem(int e){

if (tope == MAXI){ cout << "\nLa Pila
esta llena.";
cin.get();
}else
PilaSec[tope++] = e;
}

void Pila::EliminarElem(){
if (tope==0){ cout << "\nLa Pila esta
vacia.";
cin.get(); }else
PilaSec[tope--] = 0;
}

int Pila::ConsultaPila(){
if (tope==0){ cout << "\nLa Pila esta
vacia.";
cin.get();
}else return PilaSec[tope-1];
}

int Pila::VaciaPila(){ return

(tope == 0);

PROFESOR: JESUS RAMOS

PROGRAMACION II. POO MISION SUCRE

}
void Pila::MostrarPila(){ for (int i=tope-1 ; i>=0; i--) cout << "Pos["
<< i + 1 << "] = " << PilaSec[i] << endl;
}

Pila::~Pila(){
tope = 0;
for (int i =0; i<MAXI; i++)
PilaSec[i] = 0;
}

//FIN DEL ARCHIVO DE CABECERA pila.h

/****************************************** ARCHIVO
DE PRUEBA PARA LA CLASE pila.h
pruebaPila.cpp
*******************************************/
#include <iostream>
#include <cstdlib>
#include "pila.h" using
namespace std;

int main(){
system("clear"); Pila
miPila;

miPila.InsertaElem(9); cout << "Elemento en el tope: " <<

miPila.ConsultaPila() << endl; miPila.InsertaElem(5);
miPila.InsertaElem(3); miPila.InsertaElem(7);
cout << "Elemento en el tope: " << miPila.ConsultaPila() << endl;
miPila.MostrarPila(); miPila.EliminarElem();
miPila.EliminarElem(); miPila.EliminarElem();
cout << "Elemento en el tope: " << miPila.ConsultaPila() << endl;

cout << "\nF I N DEL P R O G R A M A." << endl;

}

//FIN DEL ARCHIVO DE PRUEBA pruebaPila.cpp

PROFESOR: JESUS RAMOS

PROGRAMACION II. POO MISION SUCRE

Especificación Cola[TipoEle]

Especificación Sintáctica CrearCola() Crea una cola vacía InsertaElem()

1 Ingresa un nuevo
CrearCola() Cola elemento a la cola por el fin de la misma
InsertaElem() Cola EliminarElem(), Elimina el elemento que esta
actualmente en el inicio de la cola, si la cola no
EliminarElem() Cola
esta vacía
ConsultaCola() TipoEle, VaciaCola(), Retorna Cierto si la cola esta vacía
VaciaCola() Logico, MostrarCola() . DestruyeCola(): Destruye la cola
ConsultaCola(), Retorna el elemento
2 DestruyeCola()() .
apuntado por el inicio de la cola.
Declaraciones MostrarCola(): Imprime en pantalla todos
3 TipoEle : e, {TipoEleNoDef} los elementos de la cola.
Especificación Semántica
VaciaCola(CrearCola())=Cierto
VaciaCola(InsertaElem())=Falso
ConsultaCola(CrearCola())={TipoEleNo
Def}
EliminarElem(CrearCola())=CrearCola()

/*******************************
ARCHIVO DE CABECERA cola.h
********************************/
#include <iostream>
#include <cstdlib> using
namespace std; const
int MAXI = 100;

class Cola{

PROFESOR: JESUS RAMOS

PROGRAMACION II. POO MISION SUCRE

int fin;
int ColaSec[MAXI];

public: Cola(void); void

InsertaElem(int e); void
EliminarElem(); int
ConsultaCola(); int
VaciaCola(); void
MostrarCola();
~Cola(); };
Cola::Cola(){ fin=0;
for (int i =0;i<MAXI; i++){ ColaSec[i] =
0;
}
}

void Cola::InsertaElem(int e){ if (fin ==

MAXI){ cout << "\nLa Cola esta
llena.";
cin.get();
}else
ColaSec[fin++] = e;
}

void Cola::EliminarElem(){ if (fin==0){

cout << "\nLa Cola esta vacia.";
cin.get();
}else{ for (int i = 1; i<MAXI; i++)
ColaSec[i-1] = ColaSec[i]; fin--;
}
}

int Cola::ConsultaCola(){ if (fin==0){ cout

<< "\nLa Cola esta vacia.";
cin.get();
}else return
ColaSec[0];
}
int Cola::VaciaCola(){ return
(fin == 0);
}

void Cola::MostrarCola(){ cout

<< "COLA: ";
for (int i=0 ; i<fin; i++) cout <<
ColaSec[i] << " ";
cout << endl;
}

Cola::~Cola(){

PROFESOR: JESUS RAMOS

PROGRAMACION II. POO MISION SUCRE

fin = 0; for (int i =0; i<MAXI; i++)

ColaSec[i] = 0;
}

//FIN DEL ARCHIVO DE CABECERA cola.h

/****************************************** ARCHIVO
DE PRUEBA PARA LA CLASE cola.h pruebaCola.cpp
*******************************************/
#include <iostream>
#include <cstdlib>
#include "cola.h" using
namespace std;

int main(){ system("clear");

Cola miCola;

miCola.EliminarElem(); miCola.InsertaElem(9); cout << "Elemento en el Fin: " <<

miCola.ConsultaCola() << endl;
miCola.InsertaElem(5); miCola.InsertaElem(3);
miCola.InsertaElem(7);
cout << "Elemento en el Fin: " << miCola.ConsultaCola() << endl;
miCola.MostrarCola(); miCola.EliminarElem();
miCola.EliminarElem(); miCola.EliminarElem();
cout << "Elemento en el Fin: " << miCola.ConsultaCola() << endl; miCola.MostrarCola();

cout << "\nF I N DEL P R O G R A M A." << endl;

}

//FIN DEL ARCHIVO DE PRUEBA pruebaCola.cpp

Ejercicio Propuesto

1).- Usar el ejemplo pila para obtener el binario de un numero entero dado.
#include <iostream>
#include <cstdlib> #include
"pila.h"

using namespace std;

int main(){ int

numero,cociente,resto;
system("clear"); Pila
miPila, otraPila;

PROFESOR: JESUS RAMOS

PROGRAMACION II. POO MISION SUCRE

cout << "Introduzca numero a transformar:

"; cin >> numero; cociente = (int)(numero /
2); resto = numero % 2;
miPila.InsertaElem(resto);

while (cociente >= 1){

miPila.InsertaElem(cociente%2); cociente
= (int)(cociente / 2);
} while (!miPila.VaciaPila()){
otraPila.InsertaElem(miPila.ConsultaPila()); miPila.EliminarElem();
} otraPila.MostrarPila();

cout << "\nF I N DEL P R O G R A M A." << endl;

}
2).- Usar una pila para verificar el equilibrio de paréntesis, llaves y corchetes de una ecuación,
ejemplo: [a + b/(c-d)]
#include <iostream>
#include <cstdlib>
#include <cstring> #include
"pila.h"

using namespace std;

int main(){ char Ecuacion[255]; int parentesisIni, parentesisFin, corchetesIni,

corchetesFin, llavesIni, llavesFin, i;

system("clear");
Pila miPila;

parentesisIni = 0;
parentesisFin = 0;
corchetesIni = 0;
corchetesFin = 0;
llavesIni = 0; llavesFin
= 0;

cout << "Introduzca la Ecuacion: "; cin.getline(Ecuacion,255);

PROFESOR: JESUS RAMOS

PROGRAMACION II. POO MISION SUCRE

i = 0; while (Ecuacion[i] !=
'\0'){
miPila.InsertaElem(Ecuacion[i++]);
}

while (!miPila.VaciaPila()){ switch (miPila.ConsultaPila()){ case '(':

parentesisIni++;
break;

case ')':

parentesisFin++;
break;

case '[':

corchetesIni++;
break;

case ']':

corchetesFin++; break;

case '{':

llavesIni++;
break;

case '}':

llavesFin++; break;

}
miPila.EliminarElem();
} if (parentesisIni ==
parentesisFin)
cout << "Paretesis (" << parentesisIni << " abiertos) equilibrados" << endl;

PROFESOR: JESUS RAMOS

PROGRAMACION II. POO MISION SUCRE

else
cout << "Parentesis (" << parentesisFin << " cerrados) desequilibrados" << endl;

if (corchetesIni == corchetesFin)
cout << "Corchetes (" << corchetesIni << " abiertos) equilibrados." << endl;
else
cout << "Corchetes (" << corchetesFin << " cerrados) desequilibrados" << endl;

if (llavesIni == llavesFin)
cout << "Llaves (" << llavesIni << "abiertos) equilibradas" << endl;
else
cout << "Llaves(" << llavesFin << "cerrados) desequilibradas" << endl;
cout << "\nF I N DEL P R O G R A M A." << endl;
}

PROFESOR: JESUS RAMOS