UNIVERSIDAD MARIANO GALVEZ DE

GUATEMALA
CENTRO UNIVERSITARIO DE TOTONICAPAN
INGENERIA EN SISTEMAS
PROGRAMACIN 2

CLASES
(CLASS)

Sirve para definir una clase y para declarar objetos de

esa clase. Su uso es parecido a la ya conocida struct:
class <identificador de clase> [<:lista de clases base>] {
<lista de miembros>
} [<lista de identificadores de objetos>];

La lista de clases base se usa para derivar clases

La lista de miembros ser en general una lista
de funciones y datos.

 Las funciones pueden ser simplemente

declaraciones de prototipos, que se deben
definir aparte de la clase pueden ser tambin
definiciones.
Cuando se definen fuera de la clase se debe
usar el operador de mbito "::".
Lo veremos mucho mejor con un ejemplo.

#include <iostream>
class pareja {
private:
// Datos miembro de la clase "pareja"
int a, b;
public:
// Funciones miembro de la clase "pareja"
void Lee(int &a2, int &b2);
void Guarda(int a2, int b2) {
a = a2;
b = b2;
} };

void pareja::Lee(int &a2, int &b2) {

a2 = a;
b2 = b;
} int main() {
pareja par1;
int x, y;
par1.Guarda(12, 32);
par1.Lee(x, y);
cout << "Valor de par1.a: " << x << endl;
cout << "Valor de par1.b: " << y << endl;
return 0;
}

 Nuestra clase "pareja" tiene dos miembros de

tipo de datos: a y b.
Y dos funciones, una para leer esos valores y
otra para modificarlos.
En el caso de la funcin "Lee" la hemos
declarado en el interior de la clase y definido
fuera, observa que en el exterior de la
declaracin de la clase tenemos que usar la
expresin

void pareja::Lee(int &a2, int

&b2)

Para que quede claro que nos referimos a la funcin "Lee" de

la clase "pareja". Ten en cuenta que pueden existir otras clases
que tengan funciones con el mismo nombre, y tambin que si
no especificamos que estamos definiendo una funcin de la
clase "pareja", en realidad estaremos definiendo una funcin
corriente.
En el caso de la funcin "Guarda" la hemos definido en el
interior de la propia clase. Esto lo haremos slo cuando la
definicin sea muy simple, ya que dificulta la lectura y
comprensin del programa.
Adems, las funciones definidas de este modo sern tratadas
como inline, y esto slo es recomendable para funciones
cortas, ya que, (como recordars), en estas funciones se inserta
el cdigo cada vez que son llamadas.

Dentro de la lista de miembros, cada miembro puede

tener diferentes niveles de acceso.
En nuestro ejemplo hemos usado dos de esos niveles,
el privado y el pblico, aunque hay ms.
class <identificador de clase> {
public:
<lista de miembros>
private:
<lista de miembros>
protected:
<lista de miembros>
};

ACCESO PRIVADO,
PRIVATE
Los miembros privados de una clase slo son
accesibles por los propios miembros de la clase y
en general por objetos de la misma clase, pero no
desde funciones externas o desde funciones de
clases derivadas.

ACCESO PBLICO,
PUBLIC
Cualquier miembro pblico de una clase es
accesible desde cualquier parte donde sea
accesible el propio objeto.

ACCESO PROTEGIDO,
PROTECTED
Con respecto a las funciones externas, es equivalente
al acceso privado, pero con respecto a las clases
derivadas se comporta como pblico.
Cada una de stas palabras, seguidas de ":", da
comienzo a una seccin, que terminar cuando se
inicie la seccin siguiente o cuando termine la
declaracin de la clase. Es posible tener varias
secciones de cada tipo dentro de una clase.

OBJETOS

(Class)

Un objeto es algo de lo que hablamos y que

podemos manipular
Existen en el mundo real (o en nuestro
entendimiento del mismo)
Objeto:Clase
Atributo1=valor
Atributo2=valor
...

POLIMORFISMO

Capacidad que tiene los objetos de comportarse de mltiples formas.

En C++, permite que el cdigo de sus programas tenga la posibilidad de ser usados con
diferentes tipos de datos u objetos.
Por ejemplo, supongamos que A y B son dos variables de tipo entero, entonces, la
operacin:
C= A+B
Nos devolver la suma de stos dos nmeros, cuyo resultado ser guardado en la
variable C.
Pero supongamos que A y B son del tipo String (es decir, dos cadenas de caracteres):
String A= Hola;
String B= bienvenidos a la Programacin en C++.;
String C;
C=A+B;
Al tener esa secuencia de commandos, ya no obtendremos como resultado la suma de
esos dos nmeros, sino la concatenacin de esas dos cadenas. Por tanto, el resultado
en pantalla, sera:
Hola bienvenidos a la Programacin en C++.

El polimorfismo se refiere al hecho de que una

misma funcin adopte mltiples formas. Esto se
consigue por medio de la sobrecarga:
Sobrecarga de funciones:
un mismo nombre de funcin para
distintas funciones.
a = Sumar(c,d);
a = Sumar(c,d,5);

 Sobrecarga de operadores:
un mismo operador con distintas
funcionalidades.
entero1 = entero2 + 5;
cadena1 = cadena2 + cadena3;
Podemos sobrecargar el operador + sobre la clase
cadena para que permita concatenar dos de estos
objetos.

HERENCIA

La herencia es uno de los mecanismos ms tiles de la

programacin orientada al objeto, ya que por medio
de la misma se puede llevar a cabo la reutilizacin de
cdigo. Es decir, puesto que toda clase definida se
convierte en candidata para ser usada como base de
donde se deriven otras, esto da como resultado que las
clases derivadas hereden todos los miembros de la
clase base. En ese sentido, podemos decir que existen
dos tipos de herencia, por extensin y por agregacin
o composicin. la herencia por extensin se puede
representar as:

HERENCIA POR EXTENSIN

Al tipo de diagrama mostrado (Herencia por

extensin) se le conoce como UML y es
utilizado para mostrar de forma grafica la
relacin existente entre una clase hija con la
clase padre.

AGREGACIN O COMPOSICIN
La composicin se da en los casos en donde
una clase posee un objeto que es una
instancia de otra clase. Por ejemplo, la clase
Suma podra escribirse de la siguiente forma:

class Suma {
// atributo privado
double resultado;
public:
// mtodo pblico
double calcular();
// atributo pblico
Pareja p;
};
// implementacin del metodo calcular de la clase Suma.
double Suma::calcular() { return p.getA() + p.getB(); }

Luego, si usted presta atencin, notar que el miembro p de la clase Suma es

un objeto o instancia de la clase Pareja, en consecuencia, la clase Suma
puede acceder a los miembros de la clase Pareja a travs de la variable p.
Tambin se debe observar que la implementacin del mtodo calcular() es
diferente que el mismo de la clase Suma original. Si usted desea poner a
prueba a la nueva clase Suma, compile y ejecute el siguiente programa.

MEMPRIA
DINAMICA

La memoria dinmica es un espacio de almacenamiento que se

puede solicitar en tiempo de ejecucin. Adems de solicitar
espacios de almacenamiento, tambin podemos liberarlos (en
tiempo de ejecucin) cuando dejemos de necesitarlos.
Para realizar esta administracin de la memoria dinmica, C++
cuenta con dos operadores new y delete. Antes de utilizarlos,
debemos incluir el encabezado <new>.
El operador new reserva memoria dinmica de cualquier tipo,
esto es:
tipos primitivos (int, double, etc)
tipos definidos por el usuario (clases o estructuras).

Veamos las siguientes lneas:

int *ptrEntero;
ptrEntero = new int;
/*(al puntero ptrEntero le asignamos dinamicamente
espacio para contener un valor int)*
/ int *ptrEnteroA;
ptrEnteroA = new int(5);
/*(igual que al anterior pero de paso lo inicializamos
en 5) /*

Veamos las siguientes lneas:

int *ptrEntero;
ptrEntero = new int;
/*(al puntero ptrEntero le asignamos dinmicamente
espacio para contener un valor int)*
/ int *ptrEnteroA;
ptrEnteroA = new int(5);
/*(igual que al anterior pero de paso lo inicializamos
en 5) /*

Tambin podramos hacerlo con un arreglo, para

esto:
int *arreglo = new int[45];
/* (creamos un arreglo dinmico, sta vez lo
hacemos en la misma lnea en la que
declaramos el puntero) */

Supongamos ahora que poseemos una clase Punto,

podramos crear objetos dinmicos a partir de esta
clase.
Punto *ptrQ;
ptrQ = new Punto(4,5);
/* (en la segunda lnea le pasamos adems dos
parmetros separados por coma al constructor de
Punto) */

Hemos estado pidiendo memoria dinmica, una

vez utilizada lo correcto sera liberarla antes de que
finalice el programa para esto utilizaremos el
operador delete:
delete ptrEntero;
delete ptrEnteroA;
delete ptrQ; delete
[] arreglo;
//Si no usramos [] no se liberara el arreglo entero

ARREGLOS
PILAS

Una PILA es una estructuras en donde cada

elemento es insertado y retirado del tope de la
misma, y debido a esto el comportamiento de un
una pila se conoce como LIFO (ltimo en entrar,
primero en salir ).
Un ejemplo de pila o stack se puede observar en el mismo
procesador, es decir, cada vez que en los programas aparece una
llamada a una funcin el microprocesador guarda el estado de
ciertos registros en un segmento de memoria conocido
como Stack Segment, mismos que sern recuperados al regreso
de la funcin.

PILA EN ARREGLO ESTTICO

En el programa que se ver en seguida, se simula el
comportamiento de una estructura de pila. Aunque en
el mismo se usa un arreglo esttico de tamao fijo se
debe
mencionar
que
normalmente
las
implementaciones hechas por fabricantes y/o terceras
personas se basan en listas dinmicas o enlazadas.
Para la implementacin de la clase Stack se han
elegido los mtodos:

put(), poner un elemento en la pila

get(), retirar un elemento de la pila
empty(), regresa 1 (TRUE) si la pila esta vaca size(),
nmero de elementos en la pila
El atributo SP de la clase Stack es el puntero de
lectura/escritura, es decir, el SP indica la posicin dentro de
la pila en donde la funcin put() insertar el siguiente dato, y
la posicin dentro de la pila de donde la funcin get() leer
el siguiente dato.
Cada vez que put() inserta un elemento el SP se decremento.
Cada vez que get() retira un elemento el SP se incrementa .

En el siguiente ejemplo se analiza lo que sucede con el

SP (puntero de pila) cuando se guardan en la pila uno
por uno los caracteres 'A', 'B', 'C' y 'D'. Observe que al
principio el SP es igual al tamao de la pila.
Llenando la pila
SP
|
+---+---+---+---+---+
| | | |
| | al principio (lista vaca)
+---+---+---+---+---+

SP
|
+---+---+---+---+---+ push('A');
|
| | | | A | despus de haber agregado el primer elemento
+---+---+---+---+---+

SP
|
+---+---+---+---+---+
|
| D | C | B | A | despus de haber agregado cuatro elementos
+---+---+---+---+---+

Vaciando la pila.
SP
|
+---+---+---+---+---+ pop();
|
| D | C | B | A | despus de haber retirado un elemento
+---+---+---+---+---+
SP
|
+---+---+---+---+---+
|
| D | C | B | A | despus de haber retirado todos los elementos
+---+---+---+---+---+
Nota: observe que al final la lista est vacia, y que dicho estado se debe a que el
puntero est al final de la pila y no al hecho de borrar fsicamente cada elemento
de la pila.

COLAS O
QUEUES

Una cola sencilla es una estructura en donde cada

elemento es insertado
inmediatamente despus del ltimo elemento
insertado; y donde los elementos
se retiran siempre por el frente de la misma, debido
a esto el comportamiento
de un una cola se conoce como FIFO (primero en
entrar, primero en salir).

Un ejemplo a citar de cola es el comportamiento del buffer

del teclado.
Cuando en el teclado se oprime una tecla, el cdigo del
carcter ingresado es trasladado y depositado en una rea
de memoria intermedia conocida como "el buffer del
teclado", para esto el microprocedador llama a una rutina
especfica. Luego, para leer el carcter depositado en el
buffer existe otra funcin, es decir, hay una rutina para
escribir y otra para leer los caracteres del buffer cada una
de las cuales posee un puntero; uno para saber en donde
dentro del buffer se escribir el siguiente cdigo y otro
para saber de donde dentro del buffer se leer el siguiente
cdigo.

COLA EN UN ARREGLO ESTTICO

En el programa que se ve en seguida, se simula el
comportamiento de una estructura de cola simple.
Aunque en el mismo se usa un arreglo esttico de
tamao fijo se debe mencionar que normalmente
las implementaciones hechas por fabricantes y/o
terceras personas se basan en listas dinmicas o
dinmicamente enlazadas.
Para la implementacin de la clase Queue se han
elegido los mtodos:

En el programa que se ve en seguida, se simula el

comportamiento de una estructura de cola simple.
Aunque en el mismo se usa un arreglo esttico de
tamao fijo se debe mencionar que normalmente
las implementaciones hechas por fabricantes y/o
terceras personas se basan en listas dinmicas o
dinmicamente enlazadas.

Para la implementacin de la clase Queue se han

elegido los mtodos:
put(), poner un elemento en la cola
get(), retirar un elemento de la cola
empty(), regresa 1 (TRUE) si la cola est vacia
size(), nmero de elementos en la cola El atributo
cabeza de la clase Queue es el puntero de lectura.
El atributo cola de la clase Queue es el puntero de
escritura.

Es decir, la cola indica la posicin dentro de la lista en

donde la funcin put() insertar el siguiente dato, y la cabeza
indica la posicin dentro de la lista de donde la funcin get()
leer el siguiente dato.
Cada vez que put() inserta un elemento la cola se
incrementa.
Cada vez que get() retira un elemento la cabeza se
incrementa.
En el siguiente ejemplo se analiza lo que sucede con la cola
y la cabeza (punteros de escritura y de lectura de la Lista)
cuando se guardan en la cola uno por uno los caracteres 'A',
'B', 'C' y 'D'. Observe que al principio: cola = cabeza = cero.

Llenando la cola.
cola
|
+---+---+---+---+---+
|
|
| |
| |
+---+---+---+---+---+
|
cabeza

al principio

cola
|
+---+---+---+---+---+
| A |
| |
| |
+---+---+---+---+---+
|
cabeza

put('A');
despus de haber agregado el primer elemento

cola
|
+---+---+---+---+---+
| A | B | C | D | | despus de haber agregado cuatro elementos
+---+---+---+---+---+
|
cabeza
Vaciando la cola.
cabeza
|
+---+---+---+---+---+
|A |B |C |D|
|
+---+---+---+---+---+

antes de haber retirado elementos

cabeza
|
+---+---+---+---+---+ get();
|A |B |C |D|
| despus de haber retirado un elemento
+---+---+---+---+---+

cabeza
|
+---+---+---+---+---+ al final
|A |B |C |D|
| despus de haber retirado todos los elementos
+---+---+---+---+---+
|
cola

TOP-DOWN Y
BOTTOM-UP

 Top-down (de arriba abajo) y bottom-up (de abajo arriba) son

estrategias de procesamiento de informacin caractersticas de las
ciencias de la informacin, especialmente en lo relativo al
software. Por extensin se aplican tambin a otras ciencias
sociales y exactas
En el modelo top-down se formula un resumen del sistema, sin
especificar detalles. Cada parte del sistema se refina diseando
con mayor detalle. Cada parte nueva es entonces redefinida, cada
vez con mayor detalle, hasta que la especificacin completa es lo
suficientemente detallada para validar el modelo. El modelo topdown se disea con frecuencia con la ayuda de "cajas negras" que
hacen ms fcil cumplir requisitos aunque estas cajas negras no
expliquen en detalle los componentes individuales.

MUCHAS
GRACIAS