Programación

Orientada
a Objetos
Ing. Gabriela Camarena Clemente
 Introducción
La idea fundamental de los lenguajes orientados a
objetos es combinar en una única unidad o módulo, tanto
los datos como las funciones que operan sobre esos
datos. Tal unidad se llama objeto.
Las funciones de un objeto se llaman funciones miembro
o métodos. Los datos de un objeto se conocen también
como atributos o variables de instancia.
Los datos son ocultos, de modo que están protegidos de
alteraciones accidentales. Los datos y las funciones se
dice que están encapsulados en una única entidad. El
encapsulamiento de datos y la ocultación de los datos son
términos clave en la descripción de los lenguajes
orientados a objetos.
 Declaración de constantes
A la declaración de un objeto se puede anteponer el
calificador const, con el fin de hacer que dicho objeto sea, en
lugar de una variable, una constante. Por ejemplo:

const int k=12;

const int v[]={1,2,3,4};

Cuando const se especifica a continuación de la lista de

parámetros de una función miembro de una clase, indica que
la función no puede modificar el objeto para el cual fue
invocada. También, si se declara explícitamente un objeto
const, es un error que la función miembro invocada por este
objeto no sea también const.

Función_miembro (lista_de_parámetros) const;

 2.4 Funciones en Línea (inline)
Cuando el compilador construye el código ejecutable de un programa en C++
existen dos opciones disponibles para la generación del código de las
funciones en línea y fuera de línea.
Las funciones en línea (inline) sirven para aumentar la velocidad de su
programa. Su uso es conveniente cuando la función se utiliza muchas veces
en el programa y su código es pequeño.
Una función normal es un bloque de código que se llama desde otra función.
El compilador genera código para situar la dirección de retorno en la pila.
Para una función en línea (inline), el compilador inserta realmente el código
para la función en el punto que se llama la función. Esta acción hace que el
programa se ejecute más rápidamente.
Sin embargo, cada instancia de la función en línea puede requerir tanta
memoria como se requiera para contener la función completa.
La definición de una función miembro en línea no garantiza que el compilador
lo haga realmente en línea; es una decisión que el compilador toma, basado
en los tipos de las sentencias dentro de la función y cada compilador toma
esta decisión de modo diferente.
Una función localizada fuera del bloque de la definición de una clase se puede
benificiar de las ventajas de las funciones en línea si está precedida por la
palabra reservada inline.
Inline void Punto :: FijarX (int valx)
{
x=valx;
}
 2.5 Puntero This
Cada objeto de una determinada clase mantiene su
propia copia de los datos miembro de la clase, pero no de
las funciones miembro. Por lo tanto, para que una
función miembro conozca la identidad del objeto
particular para el cual dicha función ha sido invocada, C++
proporciona un puntero al objeto denominado this. Así,
por ejemplo, si declaramos un objeto fecha1 y a
continuación le enviamos el mensaje AsignarFecha,
fecha1.AsignarFecha();
C++ define un puntero this para permitir referirse al
objeto fecha1 en el cuerpo de la función que se ejecuta
como respuesta al mensaje.
 UNIDAD III Polimorfismo
El polimorfismo es la capacidad de un programa
de cambiar de formas conforme se ejecute el
programa. Poli significa muchos y morfismo
hace referencia al cambio de forma. Un objeto
polimórfico es un objeto que puede tomar
diversas formas.
 3.1 Sobrecarga de funciones
La sobrecarga de funciones es una característica de C++
que hace los programas más legibles. Consiste en volver
a declarar una función anteriormente declarada, con
distinto número y/o tipo de parámetros. Normalmente,
cada función tiene su propio nombre que la distingue de
las demás. No obtante, se pueden presentar casos en los
que varias funciones ejecuten la misma tarea sobre
objetos de diferentes tipos, y puede resultar conveniente
que dichas funciones tengan el mismo nombre. C++
permite definir funciones con el mismo nombre si el
número y/o el tipo de los parámetros son diferentes.
 3.3 Sobrecarga de Operadores
Es el proceso de cambiar el significado de un operador.
• Los programas en C++ usan la palabra reservada operator para
sobrecargar un operador.
• Cuando se sobrecarga un operador, especifica una función que
C++ invoca cada vez que la clase usa el operador sobrecargado.
La función, a su vez, ejecuta las operaciones correspondientes.
• Cuando un programa sobrecarga un operador para una clase
específica, el significado del operador cambia sólo para esa
clase.
• C++ permite sobrecargar casi todos los operadores; sin embargo
hay 4 que no (“ . ”(Operador miembro de clase), “ .*
”(Apuntador a un operador miembro), “ :: “(Operador de
resolución) “ ?:” (Operador de expresión condicional).
 3.4 Funciones Amigas
Se puede hacer que una función que no sea
miembro de una clase tenga acceso a la parte
privada de esa clase declarándola como amiga
(friend) de la clase.
Los miembros de clase privados protegen los
datos de la clase; por lo tanto, usted debe
limitar el uso de clases amigas sólo a clases que
tengan verdadera necesidad de acceder de
modo directo a los miembros de clase privados.
 3.5 Sobrecarga de operadores de
entrada y salida
Las sentencias de flujos se utilizan para entradas y salidas,
lectura y visualización de valores (Los flujos no son parte
del lenguaje C++ pero se implementan como clases en la
biblioteca de C++. En C++ es posible sobrecargar los
operadores de inserción y extracción de modo que pueda
manipular cualquier sentencia de flujo que incluya
cualquier tipo de clase.
Sobrecargando los operadores de flujos de entrada y
salida, éstos pueden manipular, además de los tipos de
datos predefinidos (int, long, double, char*, etc.)
 Sobrecarga de flujo de salida
La sobrecarga del operador de flujo se salida << puede
añadir a sus propias clases los tipos de datos que diseñan
las sentencias de flujo de salida.
C++ tiene una clase denominada ostream que incluye
varias sobrecargas del operador << para la salida de
valores de tipos predefinidos.
La función operator<<, tras ejecutar un código que
imprimirá el dato especificado, retorna una referencia al
objeto de tipo ostream que la invocó (normalmente al
objeto predefinido cout), de forma que el operador de
inserción pueda encadenarse; esto permite insertar en
dicho objeto ostream no un solo dato, sino varios datos.
 Sobrecarga del operador de extracción

C++ tiene una clase denominada istream que

incluye varias sobrecargas del operador>> para
la entrada de valores de tipos predefinidos.
La sobrecarga de flujo de entrada >> es similar a
la sobrecarga del flujo se salida.
 3.6 Entrada y Salida de Archivos
Para poder realizar las operaciones de E/S, se necesita
incluir el archivo de cabecera fstream en el que se
definen varias clases con diferentes funciones miembro.
El archivo de cabecera <fstream> declara las clases
ifstream, ofstream y fstream.
La clase ifstream se deriva de la clase istream y permite a
los usuarios acceder a archivos y leer datos de ellos. La
clase ofstream se deriva de la clase ostream y permite a
los usuarios acceder a archivos y escribir datos en ellos.
Por último, la clase fstream se deriva de las clases
ifstream y ofstream que permite a los usuarios acceder a
los archivos para entrada y salida de datos. Para abrir y
gestionar adecuadamente las clases ifstream y ofstream
relacionadas con un sistema de archivos, se debe declarar
con un constructor apropiado.
ifstream();
ifstream(const char*, int=ios::in, int prot=filebuf::openprot);
ofstream();
ofstream();
ofstream(const char*, int=ios::out, int prot=filebuf::openprot);
El constructor sin argumentos crea una variable que se
asociará posteriormente con un archivo de entrada. El
constructor de tres argumentos toma como su primer
argumento el archivo con nombre. El segundo argumento
especifica el modo archivo. El tercer argumento es para
protección de archivos.
• La apertura de un flujo de entrada se debe declarar en la
clase ifstream.
• La apertura de un flujo de salida se debe declarar en la
clase ofstream.
• Los flujos que realicen operaciones de entrada y salida
deben declararse en la clase fstream.
 La función open
Una vez creado el flujo, se puede utilizar la
función open() para asociarlo con un archivo.
Esta función es miembro de las tres clases de
flujo.
//abre archivos ifstream
void open (const char*, int=ios::in, int
prot=filebuf::openprot);
//abre archivos oftream
void open (const char*, int=ios::out, int
prot=filebuf::openprot);
void close();
void open (const char*nomarch, int modo, int
acceso=filebuf::openprot);
El primer argumento es nombre del archivo , el segundo determina
cómo se abrirá el archivo y el tercer es protección del archivo,
especifica el permiso de acceso por defecto que se asigna a un archivo
si se crea por la función constructor. El valor por defecto es
filebuf::openprot);
Valores del argumento modo de archivo

Argumento Modo
ios::in Modo entrada
ios::app Modo añadir
ios::out Modo salida
ios::ate Añadir y buscar el fin de archivo
ios::nocreate Genera un error si no existe el archivo
ios::trunc Trunca el archivo a 0 si existe ya
ios::noreplace Genera un error si el archivo exite ya
ios::binary El archivo se abre en modo binario
Ejemplos:
//EJEMPLO 1. Abre el archivo autoexec.bat para entrada de texto.
char* cAutoExec = “\\AUTOEXEC.BAT”;
fstream f;
//abrir para entrada
f.open (cAutoexec, ios::in);
//EJEMPLO 2. Abre el archivo DEMO.DAT para salida de texto.
fstream f;
// abrir para salida
f.open (“DEMO.DAT”,ios::out);
// EJEMPLO 3. Abre el archivo PRUEBAS.DAT para entrada y salida
//binaria.
fstream f;
//abrir para E/S de acceso aleatorio
f.open(“PRUEBAS.DAT”,ios::in | ios::out |ios::binary);
//Forma habitual de abrir un archivo:
Ifstream miflujo (“miarch”); //abre el archivo
para entrada
//Código para confirmar que el archivo se ha
abierto correctamente.
ifstream miflujo (“archdemo”);
if (!miflujo) {
cout<< “No se puede abrir el archivo\n”;
//error
}
 La función close
La función miembro close cierra el archivo al
que se conecta el objeto de flujo.
void close();
Ejemplo:
fstream f;
// abrir para entrada
f.open (cAutoExec, ios::in);
// sentencias de E/S
f.close(); //cerrar bufer del flujo de archivo
 UNIDAD IV “HERENCIA”
4.1 Definición de herencia.
Es el mecanismo para compartir automáticamente
métodos y atributos entre clases y subclases. La
herencia permite definir nuevas clases a partir de otras
clases ya existentes, de modo que presentan las
mismas características y comportamiento de éstas, así
como otras adicionales.
-Tipos de Herencia.
Existen 3 tipos de herencia: pública, privada y
protegida.
 4.2 Variables y funciones miembro
protegidas.
Se puede acceder por funciones miembro de la
misma clase o de clases derivadas de la misma,
así como por amigas.
Si un miembro es protegido, los objetos de la
clase derivada pueden acceder a él como si
fuera público. Para el resto del programa, los
miembros protegidos aparecen como privados.
 4.3 Constructores y destructores
“Constructores”
Lista de parámetros Lista de parámetros
del constructor de del constructor de la
la clase derivada clase base
Nombre de la clase derivada Nombre de
la clase base

ClaseD :: ClaseD (ListaP) : ClaseBase (Lista P) , ListaMbrD

Lista de inicialización de
miembros datos de la
clase
La primera línea incluye una llamada al constructor de la clase base. El
constructor de la clase base se llama antes de que se ejecute el cuerpo del
constructor de la clase derivada, ya que el objeto base constituye el
fundamento del objeto derivado.
El constructor de una clase derivada tiene que
realizar 2 tareas:
• Inicializar el objeto base
• Inicializar todos los miembros dato
La clase derivada tiene un constructor-
inicializador, que llama a uno o más
constructores de la clase base. El inicializador
aparece inmediatamente después de los
parámetros del constructor de la clase derivada
y está precedido por dos puntos (:)
 “Destructores”
Los destructores no se heredan, aunque se
genera un destructor por defecto si se requiere.
Se utiliza cuando se quiere liberar memoria. Los
destructores se manejan como los constructores
excepto que todo se hace en orden inverso (el
destructor de la última clase derivada se ejecuta
primero).
 Para encontrar el área del cuadrado nos apoyaremos
en el triángulo rectángulo, pues este nos relaciona con
dos de los lados del cuadrado y el diámetro del círculo
que en este caso sería 2r.
Empleando el teorema de Pitágoras obtenemos:
(2r)² = L² + L²
4r² = 2L²
L² = 2r²
A = 2r²

Un cículo se caracteriza por su centro

y su radio. Un cuadrado se puede
representar también por su centro y
uno de sus vértices. Declararemos
las dos figuras geométricas como
clases derivadas.
 4.4 Clases abstractas
Una clase abstracta es aquella que posee al menos una función virtual
pura.
No es posible crear objetos de una clase abstracta, estas clases sólo se
usan como clases base para la declaración de clases derivadas.
Las funciones virtuales puras serán aquellas que siempre se definirán
en las clases derivadas, de modo que no será necesario definirlas en la
clase base.
A menudo se mencionan las clases abstractas como tipos de datos
abstractos, en inglés: Abstract Data Type, o resumido ADT.
Hay varias reglas a tener en cuenta con las clases abstractas:
• No está permitido crear objetos de una clase abstracta.
• Siempre hay que definir todas las funciones virtuales de una clase
abstracta en sus clases derivadas, no hacerlo así implica que la
nueva clase derivada será también abstracta.
 -Función Virtual

Una función virtual pura es aquella que no

necesita ser definida.
El modo de declarar una función virtual pura es
asignándole el valor cero.
Sintaxis:
virtual <tipo>
<nombre_función>(<lista_parámetros>) = 0;
 4.5 Herencia simple y herencia
múltiple
-Herencia múltiple.

Se puede hacer que una clase herede

atributos de dos o más clases. Para conseguirlo,
se usa una lista de herencia, separada por
comas.
 4.6 Conversiones entre objetos de la
clase base y clase derivada
Una clase derivada hereda todos los atributos y puede
acceder a todos ellos si son protegidos o públicos. Esto quiere
decir que hacemos una copia de los atributos( de los privados
también aunque no podamos acceder a ellos directamente).
Por eso las conversiones entre objetos de una clase derivada a
una clase base tienen sentido, ya que un objeto de la derivada
tiene todos los atributos necesarios para un objeto de la clase
base y simplemente se copian. Por ejemplo si b es un objeto
de la clase base y d un objeto de la clase derivada, podemos
hacer:
b=d;
Y se hará una copia en b de los atributos de d; los demás se
ignoran. En cambio lo contrario no es correcto:
d=b;
class base {….};
class derivada : public base {….};
main(){
base b;
derivada d;

Tipo conversión Descripción

Objeto Un objeto de la clase derivada será implícitamente convertido a
un objeto de clase base. Lo contrario no es posible.
b=d;
Referencia Una referencia a una clase derivada será implícitamente
convertida a una referencia a la clase base.
derivada &rd=d;
base &rb=b;
derivada &rd2=(derivada &)b;
derivada &rd3=static_cast<derivadas&>(b);
Puntero Un puntero a una clase derivada será implícitamente
convertido en un puntero a la clase base.
base * pb;
derivada *pd;
pb=pd
pd= (derivada *)pb; //conversión explícita
pd=static_cast<derivada *>(pb);
 Unidad V “Excepciones”
Las excepciones son en realidad errores durante la
ejecución. Si uno de esos errores se produce y no
implementamos el manejo de excepciones, el
programa sencillamente terminará abruptamente.
Es muy probable que si hay ficheros abiertos no se
guarde el contenido de los buffers, ni se cierren,
además ciertos objetos no serán destruidos, y se
producirán fugas de memoria.
En programas pequeños podemos prever las
situaciones en que se pueden producir excepciones
y evitarlos. Las excepciones más habituales son las
de peticiones de memoria fallidas.
Para implementar el control de excepciones de C++, se usan
expresiones try, throw y catch.
En primer lugar, se debe usar un bloque try para incluir una o más
instrucciones que pueden iniciar una excepción.

Una expresión throw indica que se ha producido una condición

excepcional, a menudo un error, en un bloque try. Se puede usar un
objeto de cualquier tipo como operando de una
expresión throw. Normalmente, este objeto se emplea para comunicar
información sobre el error. En la mayoría de los casos, se recomienda
usar la clase std::exception o una de las clases derivadas definidas en la
biblioteca estándar. Si no es adecuado usar una de ellas, se
recomienda derivar su propia clase de excepción de std::exception.

Para controlar las excepciones que se pueden producir, implemente

uno o varios bloques catch inmediatamente después de un
bloque try. Cada bloque catch especifica el tipo de excepción que
puede controlar.
En este ejemplo se muestra un bloque try y sus
controladores. Suponga
que GetNetworkResource() adquiere datos a
través de una conexión de red y que los dos
tipos de excepción son clases definidas por el
usuario que derivan de std::exception. Observe
que las excepciones se detectan en la
referencia const de la instrucción catch. Se
recomienda producir excepciones por valor y
detectarlas mediante la referencia const.
 5.3 Control de puertos
SALIDA DE DATOS.
Si estas utilizando un compilador de C/C++ version 3.0 de Borland o
inferior la estructura es asi:
Librería requerida: dos.h
Linea a utilizar: outportb(dir_puerto, valor);
Si se trata de un compilador C/C++ 4.0 o superior de Borland o
Microsoft: Librería requerida: conio.h
Linea a utilizar: outp(dir_puerto, valor);
Donde: dir_puerto es la direccion de memoria base que ocupa el
puerto por lo general es 0x378. Y valor es el valor en numero decimal
que se mostrara en el puerto en su equivalente visto en binario.

La función outport ( ) pone el valor de palabra en el puerto

especificado por puerto
void outport (int puerto, int palabra)
#include <dos.h>
outport <0x10,0xFF);
ENTRADA DE DATOS
Si se trata de Borland C/C++ 3.0 o inferior:
Librería: dos.h
Linea: inportb(dir_puerto+1);
Si es de Borland C/C++ 4.0 o superior o de Microsoft:
Librería: conio.h
Linea: inp(dir_puerto+1);

La función inport ( ) devuelve el valor de la palabra leída

en puerto especificado por puerto.
int inport (int puerto)
#include <dos.h>
unsigned int i;
i=inport (1);
 SALIDA

Pin 9 8 7 6 5 4 3 2
Valor 128 64 32 16 8 4 2 1
Dato D7 D6 D5 D4 D3 D2 D1 D0

ENTRADA
Pin 11 10 12 13 15 NA NA NA
Dato /D7 D6 D5 D4 D3 D2 D1 D0
 Referencias
Título Programación en C+: algoritmos, estructuras de datos y objetos

Autor Luis Joyanes Aguilar

Editor McGraw-Hill, 2006

http://c.conclase.net/curso/?cap=031
http://www.zator.com/Cpp/E4_11_6.htm
clases abstractas
https://msdn.microsoft.com/es-es/library/c8whxhf1.aspx
http://c.conclase.net/curso/?cap=038

conversiones entre objetos de la clase base y clase derivada

https://books.google.com.mx/books?id=sjxQIhrMCegC&pg=PA213&lpg=PA213&dq=conversiones+entre+objetos+de+la+clase+base+y+clase+derivada+en+c%2B%2B&source=bl&ots=xS1HTGSJ4
K&sig=KmA48jSbmuUCdq6hIvrnyAvBuCE&hl=es&sa=X&ved=0CDAQ6AEwBWoVChMI3KbfguSHyQIVDtxjCh3qiQjM#v=onepage&q=conversiones%20entre%20objetos%20de%20la%20clase%20bas
e%20y%20clase%20derivada%20en%20c%2B%2B&f=false
http://informatica.utem.cl/~mcast/ESDATOS/POO/herencia.pdf

excepciones
https://msdn.microsoft.com/es-MX/library/6dekhbbc.aspx
http://c.conclase.net/curso/?cap=043
http://www.infor.uva.es/~jmrr/tgp/tgprecurso/excepcio2.htm

puerto paralelo
http://automatizados.awardspace.com/programacion/Pparalelo.pdf
http://www.forosdeelectronica.com/f26/usar-puerto-paralelo-c-visual-basic-lab-view-2259/

delay
https://ccodigo.wordpress.com/tag/time/

archivos
file:///C:/Users/gabriela/Downloads/joyanes_c_java_y_uml_capitulo_en_linea_c33.pdf

Serie
http://virtual.uaq.mx/ingenieria/pluginfile.php/25099/mod_resource/content/10/MANUAL%20DE%20PR%C3%81CTICAS%20PROGRAMACION%20AVANZADA.pdf