PROGRAMACION I

MONOGRAFA

INTEGRANTES: JHONNY CASILLAS

HENRY CARRERA
ROBERTH JUMBO
JUAN TONGUINO

29 DE JULIO DE 2015
SANGOLQU

Contenido
1. FUNCIONES Y CLASES VIRTUALES...................................................................................... 3
2. CLASES ABSTRACTAS ............................................................................................................. 4
Reglas de uso: ................................................................................................................................. 4
Restricciones de acceso en C++ ...................................................................................................... 5
3. POLIMORFISMO......................................................................................................................... 5
Clasificacin .................................................................................................................................... 6
Diferencias entre polimorfismo y sobrecarga ............................................................................... 6
CONCLUCIONES ............................................................................................................................ 14
BIBLIOGRAFA............................................................................................................................... 14

1. FUNCIONES Y CLASES VIRTUALES.

Para que la ligadura dinmica tenga efecto en una funcin particular, C++ necesita que se
use la palabra reservada virtual cuando se declara la funcin en la clase base. La ligadura
en tiempo de ejecucin funciona nicamente con las funciones virtual es, y slo cuando
se est usando una direccin de la clase base donde exista la funcin virtual, aunque
puede ser definida tambin en una clase base anterior.
Para crear una funcin miembro como virtual, simplemente hay que preceder a la
declaracin de la funcin con la palabra reservada virtual. Slo la declaracin necesita la
palabra reservada virtual, y no la definicin. Si una funcin es declarada como virtual,
en la clase base, ser entonces virtual en todas las clases derivadas. La redefinicin de
una funcin virtual en una clase derivada se conoce como overriding.
Hay que hacer notar que slo es necesario declarar la funcin como virtual en la clase
base. Todas las funciones de las clases derivadas que encajen con la declaracin que est en
la clase base sern llamadas usando el mecanismo virtual. Se puede usar la palabra
reservada virtual en las declaraciones de las clases derivadas (no hace ningn mal), pero
es redundante y puede causar confusin.
Para conseguir el comportamiento deseado de Instrument2.cpp, simplemente hay que
aadir la palabra reservada virtual en la clase base antes de play ().
//: C15:Instrument3.cpp
// Late binding with the virtual keyword
#include <iostream>
using namespace std;
enum note { middleC, Csharp, Cflat }; // Etc.
class Instrument {
public:
virtual void play(note) const {
cout << "Instrument::play" << endl;
}
};
// Wind objects are Instruments
// because they have the same interface:
class Wind : public Instrument {
public:
// Override interface function:
void play(note) const {
cout << "Wind::play" << endl;
}
};
void tune(Instrument& i) {
// ...
i.play(middleC);
}

int main() {
Wind flute;
tune(flute); // Upcasting
} ///:~

2. CLASES ABSTRACTAS
Una clase que declara la existencia de mtodos pero no la implementacin de dichos
mtodos (o sea, las llaves { } y las sentencias entre ellas), se considera una clase abstracta.
Una clase abstracta puede contener mtodos no-abstractos pero al menos uno de los
mtodos debe ser declarado abstracto.
Para declarar una clase o un metodo como abstractos, se utiliza la palabra reservada
abstract.

abstract class Drawing

{
abstract void miMetodo(int var1, int var2);
String miOtroMetodo( ){ ... }
}

Una clase abstracta no se puede instanciar pero si se puede heredar y las clases hijas sern
las encargadas de agregar la funcionalidad a los mtodos abstractos. Si no lo hacen as, las
clases hijas deben ser tambin abstractas.
Reglas de uso:

Una clase abstracta solo puede ser usada como clase base para otras clases,
pero no puede ser instanciada para crear un objeto.
Una clase abstracta no puede ser utilizada como argumento o como retorno de una
funcin.
Si puede declararse punteros-a-clase abstracta.
Se permiten referencias-a-clase abstracta, suponiendo que el objeto temporal no es
necesario en la inicializacin.

Las clases abstractas actan como expresiones de conceptos generales de los que pueden
derivarse clases ms concretas. No se puede crear un objeto de un tipo de clase abstracta,
aunque se pueden utilizar punteros y referencias a los tipos de clase abstracta.
Una clase que contiene al menos una funcin pura virtual se considera una clase
abstracta. Las clases derivadas de la clase abstracta deben implementar la funcin virtual
pura o deben ser tambin clases abstractas.
4

Una funcin virtual se declara como "pura" mediante la sintaxis de pure-specifier (descrita
en Implementacin de protocolo de clase).
Abstraccin:
Es la ocultacin de detalles irrelevantes o que no se desean mostrar. Podemos distinguir en
una clase dos aspectos desde el punto de vista de la abstraccin:

Interfaz: lo que se puede ver/usar externamente de un objeto.

Implementacin: cmo lleva a cabo su cometido.

Resumiendo: nos interesa saber qu nos ofrece un objeto, pero no cmo lo lleva a cabo.
Restricciones de acceso en C++
En C++ se puede especificar el acceso a los miembros de una clase utilizando los siguientes
especificadores de acceso:

public: Interfaz de la clase.

private: Implementacin de la clase.
protected: Implementacin de la familia.

Estos especificadores no modifican ni la forma de acceso ni el comportamiento, nicamente

controlan desde dnde se pueden usar los miembros de la clase:

public: desde cualquier sitio.

private: desde los mtodos de la clase.
protected: desde los mtodos de la clase y desde los mtodos de las clases
derivadas.

3. POLIMORFISMO
El Polimorfismo (implementado en C++ con funciones virtuales) es la tercera
caracterstica esencial de un lenguaje orientado a objetos, despus de la abstraccin de
datos y la herencia.
De hecho, nos provee de otra dimensin para la separacin entre interfaz y la
implementacin, desacoplando el qu del cmo. El Polimorfismo permite mejorar la
organizacin del cdigo y su legibilidad as como la creacin de programas extensibles que
pueden "crecer" no slo durante el desarrollo del proyecto, si no tambin cuando se deseen
nuevas caractersticas.
La encapsulacin crea nuevos tipos de datos combinando caractersticas y
comportamientos. El control de acceso separa la interfaz de la implementacin haciendo
privados (private) los detalles. Estos tipos de organizacin son fcilmente entendibles por
5

cualquiera que venga de la programacin procedimental. Pero las funciones virtuales tratan
de desunir en trminos de tipos. En el Captulo 14, usted vio como la herencia permita
tratar a un objeto como su propio tipo o como a su tipo base. Esta habilidad es bsica
debido a que permite a diferentes tipos (derivados del mismo tipo base) ser tratados como si
fueran un nico tipo, y un nico trozo de cdigo es capaz de trabajar indistintamente con
todos. Las funciones virtuales permiten a un tipo expresar sus diferencias con respecto a
otro similar si ambos han sido derivados del mismo tipo base. Esta distincin se consigue
modificando las conductas de las funciones a las que se puede llamar a travs de la clase
base.
Clasificacin
Se puede clasificar el polimorfismo en dos grandes clases:

Polimorfismo dinmico (o polimorfismo paramtrico) es aqul en el que el

cdigo no incluye ningn tipo de especificacin sobre el tipo de datos sobre el que
se trabaja. As, puede ser utilizado a todo tipo de datos compatible.
Polimorfismo esttico (o polimorfismo ad hoc) es aqul en el que los tipos a los
que se aplica el polimorfismo deben ser explcitos y declarados uno por uno antes
de poder ser utilizados.

Diferencias entre polimorfismo y sobrecarga

El polimorfismo, suele ser bastante ventajoso aplicado desde las interfaces, ya que
permite crear nuevos tipos sin necesidad de tocar las clases ya existentes
(imaginemos que deseamos aadir una clase Multiplicar), basta con recompilar todo
el cdigo que incluye los nuevos tipos aadidos. Si se hubiera recurrido a la
sobrecarga durante el diseo exigira retocar la clase anteriormente creada al aadir
la nueva operacin Multiplicar, lo que adems podra suponer revisar todo el cdigo
donde se instancia a la clase.
La sobrecarga se da siempre dentro de una sola clase, mientras que el polimorfismo
se da entre clases distintas.
Un mtodo est sobrecargado si dentro de una clase existen dos o
ms declaraciones de dicho mtodo con el mismo nombre pero con parmetros
distintos, por lo que no hay que confundirlo con polimorfismo.
En definitiva: La sobrecarga se resuelve en tiempo de compilacin utilizando los
nombres de los mtodos y los tipos de sus parmetros; el polimorfismo se resuelve
en tiempo de ejecucin del programa, esto es, mientras se ejecuta, en funcin de que
clase pertenece un objeto.

Ejercicio
Implementacn de un programa cuya jerarqua sea al menos de ocho clases y que use
polimorfismo en lenguaje C++.

#include"circulo.h"
#include"cuadrado.h"
#include"rectangulo.h"
#include"triangulo.h"
#include"trapecio.h"
main()
{
Una_dimension obj5;
doble_dimension obj6;
triple_dimension obj7;
circulo obj;
cuadrado obj2;
Una_dimension *obj1=&obj;
Una_dimension *obj3=&obj2;
obj1->mostrar();
obj3->mostrar();

rectangulo obj4;
doble_dimension *obj8=&obj4;
obj8->mostrar();
getch();

triangulo obj9;
trapecio obj11;
doble_dimension *obj10=&obj9;
7

doble_dimension *obj12=&obj11;
obj10->mostrar();
obj12->mostrar();
}
#ifndef CIRCULO_H
#define CIRCULO_H
#include <Una_dimension.h>

class circulo: public Una_dimension

{
public:
circulo();
virtual ~circulo();
double getPerimetro();
double getSuperficie();
void mostrar();
protected:
private:
};

#endif // CIRCULO_H
#ifndef CUADRADO_H
#define CUADRADO_H
#include <Una_dimension.h>

class cuadrado:public Una_dimension

8

{
public:
cuadrado();
virtual ~cuadrado();
double getPerimetro();
double getSuperficie();
void mostrar();
protected:
private:
};

#endif // CUADRADO_H

#ifndef DOBLE_DIMENSION_H
#define DOBLE_DIMENSION_H
#include <Una_dimension.h>

class doble_dimension:public Una_dimension

{
public:
doble_dimension();
virtual ~doble_dimension();
double getDimension2();
void setDimension2(double dimension);
protected:
double dimension2;
9

private:
};

#endif // DOBLE_DIMENSION_H
#ifndef RECTANGULO_H
#define RECTANGULO_H
#include<doble_dimension.h>

class rectangulo:public doble_dimension

{
public:
rectangulo();
virtual ~rectangulo();
double getPerimetro();
double getSuperficie();
void mostrar();
protected:
private:
};

#endif // RECTANGULO_H
#ifndef TRAPECIO_H
#define TRAPECIO_H
#include<triple_dimension.h>

class trapecio:public triple_dimension

10

{
public:
trapecio();
virtual ~trapecio();
double getPerimetro();
double getSuperficie();
double lado();
void mostrar();
protected:
private:
};

#endif // TRAPECIO_H
#ifndef TRIANGULO_H
#define TRIANGULO_H
#include<triple_dimension.h>

class triangulo:public triple_dimension

{
public:
triangulo();
virtual ~triangulo();
double getPerimetro();
double getSuperficie();
void mostrar();
protected:
11

private:
};

#endif // TRIANGULO_H
#ifndef TRIPLE_DIMENSION_H
#define TRIPLE_DIMENSION_H
#include<doble_dimension.h>
#include<math.h>
class triple_dimension:public doble_dimension
{
public:
triple_dimension();
virtual ~triple_dimension();
double getDimension3();
void setDimension3(double dimension);
protected:
double dimension3;
private:
};
#endif // TRIPLE_DIMENSION_H
#ifndef UNA_DIMENSION_H
#define UNA_DIMENSION_H
#include<iostream>
#include<conio.h>
using namespace std;

12

class Una_dimension
{
public:
Una_dimension();
virtual ~Una_dimension();
double getDimension1();
void setDimension1(double dimension);
double dimension1;
virtual void mostrar();
protected:
private:
};

Evaluacin de resultados

13

CONCLUCIONES

Las funciones virtuales se caracterizan por aadir una mayor cantidad de trabajo
computacional y que, por tanto, es recomendable utilizar las prestaciones del polimorfismo,
esto es, poner la palabra clave virtual a una funcin, slo cuando estemos seguros de que
esa funcin va a ser redefinida.

Tampoco se consume mucho tiempo y se sobrecargue todo en exceso pero suele ser una
prctica comn entre los que comienzan a trabajar ms o menos en serio con el C++
utilizar prestaciones de la POO cuando no son necesarias.

El polimorfismo indica que una variable pasada esperada puede adoptar mltiples formas.

BIBLIOGRAFA
o
o
o

http://profesores.fi-b.unam.mx/carlos/java/java_basico3_5.html
http://arco.esi.uclm.es/~david.villa/pensar_en_C++/vol1/ch15s04.html
http://c.conclase.net/curso/?cap=037

14