Programacion Orientada a Obejtos C++

Programación Orientada a Objetos – Ing° Oliver A. Vilca H. Pág : 1
UNIVERSIDAD NACIONAL DEL ALTIPLANO
FACULTAD DE INGENIERÍA MECÁNICA ELÉCTRICA ELECTRÓNICA Y SISTEMAS
EESCUELASCUELA PPROFESIONALROFESIONAL DEDE IINGENIERÍANGENIERÍA DEDE SSISTEMASISTEMAS
DEPARTAMENTO ACADÉMICO DE INGENIERÍA DE SISTEMAS
PROGRAMACIÓN ORIENTADA A OBJETOS EN C++
INTRODUCCIÓN
Se considera que con anterioridad se ha desarrollado un curso de programación, y esta
familiarizado con un leguaje de programación estructurado. Asimismo seguro no hace mucho que ha
terminado los cursos de matemática básica y lo relacionado al cálculo y probabilidades, aunque sólo se
requiere de principios básicos.
Si es el caso se recomienda implementarlos en un lenguaje de programación orientado a
objetos. C++, es lenguaje de programación de propósito general que presenta muchas ventajas, por
ejemplo en su sintaxis, asimismo es eficiente en tiempo de ejecución.
En la actualidad hay varios entornos y compiladores de C++ que se pueden instalar en Uníx y
Linux, por ejemplo, el compilador “g++” esta disponible en la línea de comandos (“shell”) de la
mayoría de los Sistemas Operativos de libre distribución.
Mayor información se pude encontrar en los libros citados en bibliografía. Sin embargo, en la
presente obra se han incluido temas que en algunos textos no se disponen.

11CAPITULOCAPITULO
PPROGRAMACIÓN ORIENTADA A
OBJETOS
INTRODUCCIÓN
LAS HERRAMIENTAS Y LENGUAJES ORIENTADA OBJETOS. Permite al mundo real, ser expresado
en forma más fácil y naturalmente. La intención del paradigma Orientado a Objetos es hacer que la
programación sea más directa y auténtica. La Orientación a Objetos permite al programador
concentrarse en solo resolver el problema y obtener los resultados deseados en lugar de tratar con las
restricciones del entorno.
Un programa es básicamente un procedimiento que es utilizado para resolver un problema y obtener
resultados en un entorno de computación. En la programación orientada a objetos, los objetos son los
elementos principales de desarrollo de programas. Fue desarrollado por las limitaciones de las
anteriores técnicas de programación, como la programación estructurada.
PROGRAMACIÓN ESTRUCTURADA
La idea fundamental es romper un programa en unidades más pequeñas (funciones ó procedimientos o
subrutinas de acuerdo al lenguaje de programación). Pero a medida que el tamaño de los programas
aumenta, el énfasis se pone en los tipos de datos que se procesan. Las estructuras de datos en un
programa se hacen tan importantes como las operaciones realizadas por ellos.
Los tipos de datos se procesan en muchas funciones (Ejm. Variables globales) dentro de un programa
estructurado y cuando se producen modificaciones en dichos tipos de datos, las modificaciones se
deben hacer en cada posición que actúa sobre esos tipos de datos. En consecuencia, la tarea descrita,
además de consumir gran tiempo podría ser frustrante en programas que contengan millares de líneas
de código y centenares de funciones. Se requiere en tal sentido, un método para restringir el acceso a
los datos, ocultarlos de funciones no deseadas.
Por otro lado los programas estructurados pueden con frecuencia ser difíciles de diseñar, ya que
funciones y estructuras de datos no modelan bien el mundo real.
Es posible que en un equipo de programadores, en un programa estructurado, a cada programador se
le asigne un conjunto específico de funciones y tipos de datos. Dado que diferentes programadores
manipulan funciones independientes que comparten datos, los cambios que un programador hace a los
datos deben ser reflejados en el trabajo del resto del equipo. Finalmente los errores de comunicación se
reflejan en el diseño final.
PROGRAMACIÓN ORIENTADA A OBJETOS
La POO permite organizar los datos de un programa al igual que los objetos del mundo real, como los
departamentos de una compañía. Método de programación en el que los objetos son los elementos
principales de desarrollo.

OBJETOS. Los estudiantes, árboles, departamentos de una compañía (personal, contabilidad, ventas,
etc.), se conocen en general como objetos. Un objeto tiene una sola entidad y un único nombre, datos y
una forma de operar sobre ellos las funciones.
MENSAJES. Los objetos reciben interpretan y responden a mensajes de otros objetos. Los objetos se
comunican unos con otros llamando a los métodos. Un mensaje es la emisión o acción que hace un
objeto.
MÉTODOS. Un método actúa sobre un objeto, y determina como debe actuar el objeto cuando reciba
un mensaje. En contraste, las variables asociadas permiten almacenar información para dicho objeto.
Es el procedimiento o función que se invoca para actuar sobre un objeto, un método indica como se
ejecuta o responde a un mensaje. En C++ se denominan funciones miembro, en otros lenguajes
orientado a objetos se denomina métodos.
CLASE. (Objeto en general) es una plantilla, modelo o descripción para producir objetos de un
determinado tipo. Esta formada por los métodos y datos que definen las características comunes a
todos los objetos de esa clase. Así por ejemplo, una clase puede describir las características
fundamentales de un estudiantes universitario (nombre, número de matrícula, carrera profesional a la
que pertenece, ciclo de estudios, etc.), mientras que un objeto representara un estudiantes específico
(Carlos Flores, 002354, Ingeniería de Sistemas, III ciclo, etc.). Al elemento miembro de una clase se le
denomina objeto.
El proceso de programación en un lenguaje orientado objetos se caracteriza por:
 Crear clases, que definen la representación y el comportamiento de los objetos.
 Crear objetos a partir de la definición de las clases.
 Implementar la comunicaciones entres objetos a través del envío de mensajes.
Un programa orientado a objetos realiza fundamentalmente tres cosas.
 Crea los objetos requeridos.
 Los mensajes enviados a los objetos dan lugar a que se procese información internamente.
 Cuando los objetos no son necesarios son destruidos, liberándose el espacio de memoria
ocupado por ellos.
La POO presenta algunas desventajas, como la ejecución de un programa es más lenta y obliga al
usuario aprender una amplia librería de clases antes de empezar a manipular un lenguaje orientado a
objetos.
DEFINICIÓN DE UNA CLASE EN C++. La sintaxis es similar a una estructura (struct), añadiendo la
posibilidad de controlar el grado de acceso a los datos y métodos de las clase, determinados por las
declaraciones public (publica), private (privada) y protected (protegida).
class x {
private:
// Miembros privados.
protected:
// Miembros protegidos.
public:
// Miembros públicos.
};
1. Definir la clase:

class Empleado {
private
int codigo;
char nombre[40];
public:
void registrar(int codigo, char *nombre);
void borrar(int codigo);
};
2. Crear un objeto con valores indefinidos.
Empleado bibliotecario;
3. Enviar un mensaje al objeto.
bibliotecario.registrar(454,”Juan_Torres”);
PROPIEDADES DE LA POO
ENCAPSULAMIENTO. Ocultamiento de los datos de un objeto, con el objetivo de manejarlos como
unidades básicas, permaneciendo oculta su estructura interna y los detalles de implementación. Permite
ver al objeto como una caja negra, no obstante se debe considerar en el diseño como se accede al
objeto.
En C++ la encapsulación se manipula mediante las palabras reservadas: private, public y proctected.
(detalles en el capítulo 4).
HERENCIA. Herramienta o propiedad para compartir automáticamente métodos y datos entre clases y
subclases. Permite a los objetos ser construidos a partir de otro antepasado, se sustenta en la definición
de la vida diaria, por ejemplo los animales se divides mamíferos, ovíparos, etc. Asmismo, los
mamíferos se pueden seguir subdividiendo en clases y subclases.
Esta propiedad da paso a la reutilización de código en la programación orientada a objetos.
En C++, herencia equivale a derivación de clases. Se utiliza el término clase padre y clase derivada.
POLIMORFISMO. Propiedad mediante el cual se puede implementar de diferentes maneras un mismo
método, dependiendo de la clase sobre la que se efectúa la implementación. Permite que objetos
distintos respondan de diferentes modos al mismo mensaje.
En C++, se emplea utilizando clases derivadas, funciones virtuales y punteros a objetos.

22CAPITULOCAPITULO
CCONSTRUCTORES Y
DESTRUCTORES
INTRODUCCIÓN
Cuando se define un objeto también es necesario una forma de inicializarlos. Los constructores y
destructores poseen tales características. Aquí se explica la forma en que cada uno se define para una
clase.
1. CONSTRUCTORES
Función miembro especial, su objetivo es realizar operaciones de inicialización para un objeto cuando
se la declara. Se identifica por tener el mismo nombre de la clase. Un constructor no requiere tipo de
retorno, es implícito, apuntador a la propia clase.
EJEMPLO: En la clase punto el constructor obliga indicar en el momento de la creación de un objeto
los valores de sus coordenadas. A diferencia de fijarXY(), no se indica el tipo de retorno.
class punto
{
int Datox;
int Datoy;
public:
punto ( int x, int y );
void fijarXY(int , int);
};
punto::punto(int x, int y)
{
Datox = x;
Datoy = y;
}
Ahora se debe especificar el objeto de tipo punto e inicializarlo al mismo tiempo. Se crea un
objeto con coordenadas (12,15).
punto p1 = punto(12,15);
Se puede escribir de forma abreviada como:
punto p1(12,15);
2.1 MÚLTIPLES CONSTRUCTORES.

Una clase puede tener varios constructores, sin embargo deben diferir en el número de sus argumentos.
EJEMPLO: A la clase punto se le agrega dos constructores, el primero definido a para coordenadas
polares, es el que se encarga de la transformación de coordenadas polares a cartesianas. El
segundo es en el caso de que no se especifique ningún parámetro, en este caso el
constructor le asignara valores por defecto.
class punto
{
int Datox;
int Datoy;
public:
punto ( int, int ); // coordenadas cartesianas.
punto ( double, double ); // coordenadas polares.
punto ( ); // origen.
void fijarXY(int , int);
};
punto::punto(int x, int y)
{
Datox = x;
Datoy = y;
}
punto::punto(double distancia, double angulo)
{
Datox = (int) (distancia * cos(angulo) );
Datoy = (int) (distancia * sin(angulo) );
}
punto::punto( )
{
Datox = 0;
Datoy = 0;
}
2.2 ARGUMENTOS POR OMISIÓN.
Valor que adopta el argumento de la función, cuando en la llamada no se especifica su valor. El valor
predeterminado o por defecto para el argumento se especifica en la declaración de la función.
Los argumentos por omisión no son necesariamente constantes, mas bien pueden ser expresiones
compuestas, siempre que las variables que lo conforman estén al alcance de la definición de la función.
EJEMPLO: En la clase cuadrado, se tiene la opción de especificar la dimensión de lado o dejarla sin
especificar, en este caso se usa el valor por omisión.
class Cuadrado
{

int Lado;
public:
Cuadrado ( int dato = 10);
void FijarLado(int);
};
Cuadrado::Cuadrado( int dato )
{
Lado = dato;
}
Ahora se debe especificar el objeto de tipo cuadrado escribiendo o no su valor.
Cuadrado cuad(12); // Cuadrado de lado 12.
Cuadrado cuad(11); // Cuadrado de lado 11.
Cuadrado cuad; // Cuadrado de lado 10.
2.3 CONSTRUCTOR COPIA.
Se emplea para crear un nuevo objeto y definirlo a partir de los valores de otro objeto de la misma
clase. Un constructor copia se crea por defecto por el compilador si no se ha proporcionado uno.
EJEMPLO: En la clase cuadrado, se tiene la opción de especificar la dimensión de lado o dejarla sin
especificar, en este caso se usa el valor por omisión.
class Complejo
{
double Real;
double Imag;
public:
Complejo ( double, double);
Complejo ( const Complejo & );
};
Se crea un objeto c1, luego otro objeto c2, a partir del objeto c1.
Complejo c1(12,15); // Constructor ordinario.
Complejo c2 = c1; // Constructor copia.
1. DESTRUCTORES
De la misma forma en que un constructor inicializa un objeto cuando se la declara, un destructor lo
suprime (destruye) cuando el objeto ya no se necesita en el programa. Se llama automáticamente
cuando se destruye el objeto, no tiene argumentos. Se identifica por tener el mismo nombre de la clase,
antecedido por el símbolo ~.
Algunos objetos pueden necesitar memoria adicional asignada al montículo (heap). Así por ejemplo se
puede requerir un arreglo de caracteres cuya longitud se determina dinámicamente. El constructor

puede utilizar el operador new para asignar una cantidad de bytes determinada en tiempo de ejecución,
para este caso es necesario también liberar la memoria reservada mediante el operador delete en el
destructor.
EJEMPLO: En la clase persona contiene un variable miembro nombre, que es un puntero a una cadena
de carateres. Para definir a una persona se pasa como argumento como cadena el nombre
de la persona, el constructor en seguida le asigna un espacio en memoria de acuerdo al
tamaño del nombre del objeto. El destructor se encarga de liberar la memoria ocupada por
objeto.
class Persona {
char *nombre;
public:
Persona(char *);
~Persona();
};
Persona::Persona(char *dato)
{
int tamanho;
tamanho = strlen(dato);
Nombre = new char[tamanho + 1];
}
Persona:: ~Persona(char *dato)
{
delete Nombre;
}

33CAPITULOCAPITULO
CCLASES AMIGAS
INTRODUCCIÓN
La palabra clave friend, permite a una función o clase acceder a la miembros privados y protegidos de
una clase.
1. CLASES AMIGAS
Una clase amiga es aquella en donde todas sus funciones miembros son funciones amigas de una clase,
esto es, que sus funciones miembro tienen acceso a los miembros privados y protegidos de otra clase.
EJEMPLO: La clase ExpedienteX le otorga confianza, por lo tanto acceso a la clase Espía, esto
mediante la declaración ‘friend class’. De esto la clase Espía toma ‘ventaja’ copiando y
cambiándolo el dato privado de la clase ExpedienteX.
class ExpedienteX {
private:
int TopSecret;
public:
friend class Espia;
};
class Espia {
private:
int Copia;
public:
void Sabotear(EspedientesX clase);
};
Espia:: Sabotear(EspedientesX clase)
{
Copia = clase.TopSecret;
clase.TopSecret = 0;
}
La relación de amistad entre clases no es mutua, excepto se indique explícitamente, en el ejemplo la
clase ExpedienteX no puede acceder a los datos privados de la clase Espía.
La relación entre clases amigas no se hereda, las clases derivadas de clase Espía no podrán acceder a
los miembros privados de la clase ExpedienteX. No es transitiva, así clases que son amigas de Espía,
no podrán acceder a los miembros privados de la clase Espía.

2. FUNCIONES AMIGAS
Una función miembro, es una función que no es miembro de una clase, pero que tiene acceso a los
miembros privados y protegidos de una clase.
Una función amiga es declarada por una clase que esta garantizando acceso. La declaración puede se
ubicada en cualquier lugar de la declaración de la clase.
EJEMPLO: La función Operator+ es una función amiga y tiene acceso a la parte privada de los objetos
de la clase complejo, recibe a los objetos en sus parámetros.
class Complejo
{
private:
float real, imag;
public:
Complejo( float re, float im );
friend Complejo operator+(Complejo first,
Complejo second);
};
Complejo operator+( Complejo first, Complejo second )
{
return Complejo( first.real + second.real,
first.imag + second.imag );
}

44CAPITULOCAPITULO
SSOBRECARGA
INTRODUCCIÓN
El concepto de sobrecarga es familiar, así por ejemplo se pude sumar dos enteros, dos reales, dos
reales dobles, así sucesivamente. Pero habitualmente no podemos tomar dos tipos complejos, como
una matriz y sumarlos con el operador +.
Es válido:
3 + 7 Suma de enteros
3.5 + 6.87 Suma de reales
No es válido:
[2,4,5] + [3,7,12] Suma de matrices
Es el caso de sobrecarga de operadores, del mismo modo existe sobrecarga de funciones, que se
explicará en seguida.
SOBRECARGA DE FUNCIONES
Es una función que tiene mas de una definición, considerando que cada definición utiliza el mismo
nombre, las definiciones operan como si fueran funciones diferentes. Entonces se dice que la función
esta sobrecargada, debido a que se puede interpretar de más de una forma. Ejemplo la función suma
sobrecargada:
int suma(int a, int b); // Función suma de enteros
string suma(string a, string b); // Función suma de cadenas
Así si se llama a suma con los argumentos (10,24), el compilador tendrá en cuenta que la
función a utilizar es aquella cuyos argumentos son enteros.
Resultado = suma(10,24);
La sobrecarga de funciones no solo se da cuando los argumentos son de distintos tipos, sino también
cuando el número de argumentos es diferentes, o ambos a la vez.
EJEMPLO:
class Tiempo{
unsigned int segs;
public:
void fijar(int ticks)
{
segs = int(ticks/100);
}
void fijar(int horas, int minutos, int segundos);
{
int sh,sm;
sm = minutos*60;

sh = horas*60*60;
segs = sh + sm + segundos;
}
};
Tiempo Cron1, Cron2;
Cron1.fijar(2000); //En Cron1, seg = 20
Cron1.fijar(1,1,1); //En Cron2, seg = 3661
SOBRECARGA DE OPERADORES
Como se efectuó la introducción un operador sobrecargado, es capaz de desarrollar su función en
varios contextos diferentes, sin la necesidad del auxilio de otras operaciones adicionales. El operador
suma “+”, es un operador sobrecargado, pues significa operaciones diferentes, como suma de enteros,
números reales. Incluso podemos dotar al mencionado operador para que sume números complejos.
EJEMPLO:
Supongamos dos vectores:
U = (a,b)
V = (c,d)
Se requiere calcular la suma de mencionados vectores:
S = U + V = (a+c,b+d)
S = (m,n)
Donde:
m = a+c
n = b+d
class complejo{
double real, img;
public:
complejo(double i =0, double j=0) // Constructor
{ real=i; img=j; }
complejo operator+ (complejo); // Operador suma de complejos
complejo operator– (complejo); // Operador resta de complejos
complejo operator* (complejo); // Operador multiplicación
complejo operator/ (complejo); // Operador división
};
complejo complejo::operator+ (complejo v)
{
return complejo( real + v–>real , img + v–>img);
}
complejo complejo::operator- (complejo v)
{
return complejo( real – v–>real , img – v–>img);
}
Complejo U(2,3), V(4,5), S, D, J, K, L;
S = U + V; // El complejo S es [6,8].

D = V – U; // El complejo D es [2,2]
J = S; // El complejo J es [6,8]
// El complejo S se asigna a J (copia objeto S en J).
K = D + complejo(6,7); // El complejo K es [8,9]
L = U + V – K; // El complejo L es [-2,-1]
Observe que el operador “=” para complejos, el compilador lo define, por defecto.
OPERADORES. Se pueden sobrecargar los siguientes operadores:
Unarios:
+ - * ! ~ &
++ – () -> new delete
Binarios:
+ - * / % & | ^ << >>
= += –= /= %= &= |= ^= <<= >>=
== != < > <= >= && || [] ()
No se puede definir como binario un operador estrictamente unario (como ~); tampoco se
puede definir como unario un operador estrictamente binario (como =).
Las reglas de precedencia para los operadores predefinidos están fijas y no pueden
modificarse. Así no importa cómo se sobrecargue ‘*’, siempre tendrá una precedencia más alta que
‘+’.
EJERCICIOS PROPUESTOS:___________________________________
1. Implemente el operador multiplicación “*”, división ”/”, y el operador unario “~” para la clase
complejo.
complejo complejo::operator~ ()
{
return complejo( -real , -img);
}
Nota:
Supongamos dos vectores:
U = (a,b)
V = (c,d)
El producto de los vectores es:
P = U * V
P = (a*c – b*d , a*d + b*c)
El cociente de los vectores es:
C = U / V
C = (
a∗c+b∗d
c2
+d2 ,
b∗c−a∗d
c2
+d2 )
2. Implemente el operador unario “Seno” y “Coseno” para la clase complejo.

[Sugerencia utilice una función amiga].

55CAPITULOCAPITULO
HHERENCIA
INTRODUCCION
DERIVACIÓN DE CLASES. Muchas veces las clases tienen algo en común. La definición separada
induce a la duplicación de código, lo que significa desperdicio de memoria y esfuerzo. Se debería
escribir una sola vez y utilizar para producir todas las variantes necesarias. En esto consiste el
mecanismo de derivación, es decir, la capacidad de obtener una nueva clase a partir de una ya
existente (llamada clase base). Se dispone de control sobre la forma en que se deriva una clase, ocultar
a la nueva clase cualquiera de las funciones miembro de la clase base o redefinir las funciones de esta
última.
CLASES DERIVADAS. La clase puede derivarse de una existente mediante el siguiente formato.
class NombreClaseDerivada : [ public | private ] NombreClaseBase
{
// Declaraciones de la clase.
};
Las palabras ‘public’ y ‘private’ en la clase derivada son opcionales. Indica cómo los miembros de la
clase base tienen que ser accesibles a la clase derivada.
ESPECIFICADORES DE ACCESO DE LA CLASE. Las palabras reservadas public, private y protected
están disponibles como modificadores de visibilidad de los miembros de la clase. Así un miembro
público es visible en todo su ámbito. El empleo específico se explica en el capitulo herencia.
class x {
private:
// Miembros privados.
protected:
// Miembros protegidos.
public:
// Miembros públicos.
};
ACCESIBILIDAD A LA CLASE. La accesibilidad y visibilidad de las variables o funciones miembro de
una clase se determina mediante un especificador de acceso.
Especificador
de Acceso
Desde la
propia clase
Desde la clase
derivada
Desde objetos
fuera de la clase
Public : SI SI SI
Protected : SI SI NO
Private : SI NO NO

EJEMPLO: Se implementa la clase polígono, de él se deriva la clase cuadrado.
class Polígono
{
private:
int numero;
double longitud;
public:
FijarDatos( int n , double l );
};
class Cuadrado : Polígono // Cuadrado se deriva de Polígono.
{
public:
double Area();
};
La clase cuadrado contiene lo mismo que polígono, además dispone de la función miembro
Area. Sin embargo, los miembros públicos de polígono, son privados para la clase derivada.
En seguida una declaración alternativa.
class Cuadrado : public Polígono // Cuadrado se deriva de Polígono.
{
public:
double Area();
};
La inserción de la palabra reservada “public”, hace los miembros públicos de Polígono
también sean públicos en cuadrado.
EJEMPLO: Implementación de la clase estudiante a partir de la clase persona.
class persona {
char *nombre;
public:
void ingresar_persona(char *x);
{
nombre = new char[strlen(x)+1];
srtcpy(nombre,x);
{
};
class estudiante : public persona {
unsigned int codigo;
public:
void ingresar_estudiante(char *m, unsigned int n);
{
ingresar_persona(m);
codigo = n;
{

}
FUNCIONES VIRTUALES. Algunas funciones miembro requieren redefinirse en las clases derivadas,
debido a algunos ajustes. Las declaraciones virtuales indican que una función tendrá diferentes
implementaciones en las clases derivadas con el mismo nombre. No deberá ser declarada virtual más
que en la clase base.
Si una función F() esta declarada virtual; esto indica que será diferente según sea su posición en la
clase base o en la clase derivada.
EJEMPLO: Clase A y B con función virtual F().
class A {
private:
int x;
public:
virtual void F ( );
};
class B : public A {
private:
int y;
public:
void F ( );
};

66CAPITULOCAPITULO
PPARAMETRIZACION
INTRODUCCIÓN
La posibilidad de diseñar clases y funciones que actúan sobre diferentes tipos de datos (genéricos), se
definen tipos parametrizados o genéricos. En Ada los paquetes, en C++ los templates. Se utiliza para
algoritmos que son independientes del tipo de objetos sobre los cuales procesa. Las clases genéricas o
parametrizadas se denominan también clases contenedoras (container class). Fue propuesta por Bjarne
Stroustrup.
FUNCIÓN PLANTILLA
Describe un conjunto de funciones y describe las propiedades genéricas de una función.
La sintaxis de la plantilla de funciones, es utilizando la palabra reservada “template”.
CON UN PARÁMETRO.
template <class Tipo> Tipo función(Tipo a)
{
// Cuerpo de la función
}
CON DOS PARÁMETROS, DEBEN SER DISTINTOS:
template <class Tipo1, class Tipo2> Tipo1 función(Tipo1 a, Tipo2 b)
{
// Cuerpo de la función
}
La función plantilla puede ser extern, inline o static, del mismo modo que una función no template. El
especificador se ubica a continuación de la lista de parámetros.
template <class Tipo> static Tipo función(Tipo a)
{
// cuerpo de la función
}
EJEMPLO: La función max devuelve el máximo valor de dos datos (de hecho para compararlos los
datos deben ser del mimo tipo).
template <class Tipo> Tipo max (Tipo a, Tipo b)
{

if ( a > b)
return a;
else
return b;
}
Se podrá utilizar, con distintos tipos de parámetros (enteros, caracteres, doubles, etc).
int ia = 2, ib = 1;
ic = max (ia, ib);
// asigna: ic = 2.
char ca = ‘a’, cb = ‘z’;
cc = max (ca, cb);
// asigna: cc = ‘z’.
double da = 123.456, db = 654.321;
dc = max (da, db);
// asigna: dc = 654.321.
EJEMPLO: La función Intercambia, permuta dos valores del mismo tipo.
template <class Tipo> void Intercambia (Tipo &a, Tipo &b)
{
Tipo aux(a);
a = b;
b = aux;
}
Se podrá utilizar, con distintos tipos de parámetros (enteros, caracteres, dobles, etc).
int ia = 2, ib = 1;
Intercambia (ia, ib);
char ca = ‘a’, cb = ‘z’;
Intercambia (ca, cb);
double da = 123.456, db = 654.321;
Intercambia (da, db);
EJEMPLO: La función Ordenar, Ordena los datos de un arreglo A[] de tamaño n. Para ello
utilizaremos la función template Intercambia. Y el método de ordenación “Bubble Sort”,
que se explica a continuación.
Se le conoce también como algoritmo de ordenación por intercambio directo. La idea
básica es imaginar que los registros a ordenar están almacenados en un arreglo (o vector)
vertical, los elementos con datos menores son “ligeros” y suben. El nombre se debe a que se
puede explicar con la siguiente analogía: imagine que el arreglo es un tubo de ensayo lleno de
líquidos de diversa densidad y que no se mezclan. Se coloca el tubo de ensayo verticalmente,
los líquidos “mas ligeros” suben como si fueran burbujas. Por tiempos (recorridos) en el

primer recorrido el más ligero sube a la superficie, así sucesivamente hasta que el tubo de
ensayo queda “ordenado” los “más ligeros” arriba.
Similarmente el método consiste en una serie de intercambios de pares de elementos
adyacentes por recorridos de abajo hacia arriba. Si hay dos elementos adyacentes que no están
en orden, es decir, si el “más ligero” esta abajo se efectúa el intercambio, este proceso se inicia
comparando el ultimo con el penúltimo elemento (si corresponde se hace el intercambio), en
seguida el penúltimo con el antepenúltimo, de tal forma que después del primer recorrido, el
elemento “más ligero” de todos, ha subido a la superficie. En el segundo recorrido, el segundo
elemento menor sube a la segunda posición, así sucesivamente. Teniendo en cuenta que en el
segundo recorrido no es necesario subir hasta la primera posición, pues se conoce que la clave
menor esta ahí.
FUNCION Ordenar (TipoElemento A[],Integer n)
{
Integer i,j;
for i = 1 to n – 1 do
{
for j = n downto i + 1 do
if ( A[j] < A[j – 1] ) then
Intercambia (A[j] , A[j – 1);
}
}
Teniendo en cuenta lo expuesto la función template sería:
template <class Tipo> void Ordenar (Tipo *A, int n)
{
int i,j;
for (i = 1; i < n ; i ++)
{
for (j = n; j > i ; j --)
if ( A[j] < A[j – 1] )
Intercambia (A[j] , A[j – 1);
}
}
CLASES PARAMETRIZADAS
Para definir clases genéricas, que manejan diferentes tipos de datos. Por ejemplo es posible
implementar una clase vector genérico que puede contener diversos tipos de datos predefinidos o
definidos por el usuario.
La sintaxis de la plantilla de funciones, es utilizando la palabra reservada template.
template <class Tipo> class NombreClase
{
// Implementación de la clase
};

EJEMPLO: La clase Pila, manipula diferentes tipos de datos en un arreglo[] de tamaño 100. Para ello
utilizaremos la función miembro Insertar, Extraer, Vacía.
template <class Tipo>
class Pila
{
int num_elem;
public:
Tipo arreglo[100];
Pila() { n = 0;}
Void Insertar(Tipo elemento);
Tipo Extraer();
int Vacia();
};
La clase pila es una clase parametrizada para cualquier tipo de dato, por lo tanto se pude
utilizar pilas de diferentes tipos de datos.
EJERCICIOS PROPUESTOS:______________________________________
1. Declarar una plantilla abs, que devuelva el valor absoluto de cualquier tipo de dato predefinido o
incorporado.
2. Implementar la función template QuickSort, que clasifique los datos de un arreglo A[] de tamaño
n. Utilize el método de ordenación “Quick Sort”. Compruebe con un arreglo de datos.
3. Implementar la clase template Cola, con las funciones miembro: Insertar, Obtener y Vacía, utilice
asignación dinámica de memoria.

Programacion Orientada a Obejtos C++

Más contenido relacionado

La actualidad más candente

Destacado

Similar a Programacion Orientada a Obejtos C++

Último

Programacion Orientada a Obejtos C++