PARADIGMAS

POLIMORFISMO PARADIGMA
Uno está enamorado cuando se da cuenta
que otra persona es única..!!
Jorge Luis Borges
Qué es esto..??
Altas
Adjunto.CPP
Adjunto.H
| Volver | | Arbol | | Archivo | | Base de dato | Basico | | Cola y Pila |
| Editor | | Editor2 | | Fibonacci | | Hanoi | | Listas | | Matriz |
| Modelo 1 | | Modelo | | Agenda | Punteros | | Sobrecarga | | Vectores |
PARADIGMA
Quienes creen que el dinero lo hace todo
terminan haciendo todo por dinero..!!
Voltaire
My virtual friend, en este caso mi propuesta es verificar una de las características de la programación orientada a objetos, por ello solo debes copiar textualmente en el editor de tu entorno de programación C++, luego compilar y ya está..!! verás en funcionamiento el polimorfismo.
Suerte..!!
////////////////////////////////////////////////////////// // C++ Builder APLICACION DE POLIMORFISMO // Wilo Carpio Programa Principal: Polimorfismo.cpp // Programas Adjuntos: Vehiculo.H // Vehiculo.cpp // Los tres elementos basicos de la POO son // Encapsulación, Herencia y Polimorfismo ////////////////////////////////////////////////////////// #include #pragma hdrstop #include #include "Vehiculo.H" USEUNIT("Vehiculo.cpp");

Qué es estoPrograma Principal
//////////////////////////////////////////////////////////
// FUNCION PRINCIPAL DEL PROGRAMA
//////////////////////////////////////////////////////////
WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
//////////////////////////////////////////////////////
// DECLARACION DE UNA MATRIZ, CUYOS OBJETOS
// SERÁN 5 VEHICULOS DIFERENTES
/////////////////////////////////////////////////////
TVehiculo * X[6];
AnsiString Cadena;

//////////////////////////////////////////////////////
// Creamos 5 objetos derivados de TVehiculo
/////////////////////////////////////////////////////
X[0] = new TBicicleta;
X[1] = new TMountanBike(18);
X[2] = new TMountanBike(21);
X[3] = new TAutomovil(5, False, 110);
X[4] = new TAutomovil(4, True, 280);
X[5] = new TCamion(4, True, 320);

Visualizaciónde resultados
//////////////////////////////////////////////////////
// TITULO PARA VISUALIZAR LOS DATOS
/////////////////////////////////////////////////////
Cadena = "C++Builder: PROGRAMACION ORIENTADA A OBJETOS Wilo Carpio\n\n"+
AnsiString("\t APLICACION DE POLIMORFISMO \n\n")+
AnsiString("VEHICULO _|_ NºEjes _|_ Ruedas_|_Motor_|_Otros \n\n ");

//////////////////////////////////////////////////////
// Recorrer la matriz para visualizar sus datos
/////////////////////////////////////////////////////
for(int N = 0; N < 6; N++)
{
Cadena = Cadena + X[N]->Nombre() +
"\t__|__" + AnsiString(X[N]->NumeroDeEjes()) +
"__|__" + AnsiString(X[N]->NumeroDeRuedas()) +
"__|__" + AnsiString((int )X[N]->FuncionaConMotor());

///////////////////////////////////////////////
// Si el vehículo es una bicicleta de montaña
// hacer un moldeado de tipo para acceder al
// método NumeroDeCambios
///////////////////////////////////////////////
if(typeid(*X[N]) == typeid(TMountanBike))
Cadena = Cadena + "__|__" +
AnsiString(((TMountanBike *)X[N])->NumeroDeCambios()) +
" cambios";

///////////////////////////////////////////////
// Si el vehículo es un automovil
// hacer un moldeado de tipo para acceder al
// método Potencia
///////////////////////////////////////////////
if(typeid(*X[N]) == typeid(TAutomovil))
Cadena = Cadena + "__|__" +
AnsiString(((TAutomovil *)X[N])->Potencia()) + " CV";

///////////////////////////////////////////////
// Si el vehículo es un Camion
// hacer un moldeado de tipo para acceder al
// método Potencia
///////////////////////////////////////////////
if(typeid(*X[N]) == typeid(TCamion))
Cadena = Cadena + "__|__" +
AnsiString(((TCamion *)X[N])->Potencia()) + " CV";

Cadena = Cadena + "\n"; // Saltar a la siguiente línea
}
////////////////////////////////////////////
// Visualizamos la cadena
////////////////////////////////////////////
ShowMessage(Cadena);

////////////////////////////////////////////
// Destruimos los objetos
////////////////////////////////////////////
delete [] X;

return 0;
}

Programa AdjuntoVehiculo.cpp
//////////////////////////////////////////////////////////
// C++ Builder APLICACION DE POLIMORFISMO
// Wilo Carpio Programa adjunto
// Vehiculo.cpp
//////////////////////////////////////////////////////////
// Codificación de los métodos
//////////////////////////////////////////////////////////
#include
#pragma hdrstop
#include "Vehiculo.h"

//////////////////////////////////////////////////////////
// Codificación del constructor que Inicializa la clase TVehiculo
//////////////////////////////////////////////////////////
TVehiculo::TVehiculo(short Ejes, short Ruedas, bool Motor)
{
NEjes = Ejes; // Guardar los datos facilitados
NRuedas = Ruedas;
TieneMotor = Motor;
}

//////////////////////////////////////////////////////////
// Codificación del método NumeroDeEjes
//////////////////////////////////////////////////////////
short TVehiculo::NumeroDeEjes()
{
return NEjes;
}

//////////////////////////////////////////////////////////
// Codificación del método NumeroDeRuedas
//////////////////////////////////////////////////////////
short TVehiculo::NumeroDeRuedas()
{
return NRuedas;
}

//////////////////////////////////////////////////////////
// Codificación del método FuncionaConMotor
//////////////////////////////////////////////////////////
bool TVehiculo::FuncionaConMotor()
{
return TieneMotor;
}

//////////////////////////////////////////////////////////
// Codificación del constructor del tipo TBicicleta,
// que no recibe parámetros y fija los datos básicos
// de este tipo de vehículo.
//////////////////////////////////////////////////////////
TBicicleta::TBicicleta() : TVehiculo(2, 2, false)
{
}

//////////////////////////////////////////////////////////
// Codificación del método Nombre, que devuelve
// el nombre del vehículo.
//////////////////////////////////////////////////////////
AnsiString TBicicleta::Nombre()
{
return "Bicicleta";
}

//////////////////////////////////////////////////////////
// Constructor del tipo TBicicletaMontana, que recibe
// como parámetro el número de cambios
//////////////////////////////////////////////////////////
TMountanBike::TMountanBike(short Cambios)
{
NCambios = Cambios; // Guardar el dato adicional recibido
}

//////////////////////////////////////////////////////////
// Codificación del método Nombre
//////////////////////////////////////////////////////////
AnsiString TMountanBike::Nombre()
{
return "MountainBike";
}

//////////////////////////////////////////////////////////
// Codificación del método NumeroDeCambios
//////////////////////////////////////////////////////////
short TMountanBike::NumeroDeCambios()
{
return NCambios;
}

//////////////////////////////////////////////////////////
// Codificación del constructor del tipo TAutomovil
//////////////////////////////////////////////////////////
TAutomovil::TAutomovil(short Cambios, bool Automatico, int Potencia)
: TVehiculo(2, 4, true)
{
NCambios = Cambios; // Preservar el resto de los datos
CAutomatico = Automatico;
NPotencia = Potencia;
}

//////////////////////////////////////////////////////////
// Codificación del método Nombre de TAutomovil
//////////////////////////////////////////////////////////
AnsiString TAutomovil::Nombre()
{
return "Automóvil"
}
//////////////////////////////////////////////////////////
// Codificación del método NumeroDeCambios de TAutomovil
//////////////////////////////////////////////////////////
short TAutomovil::NumeroDeCambios()
{
return NCambios;
}

//////////////////////////////////////////////////////////
// Codificación del método EsAutomatico de TAutomovil
//////////////////////////////////////////////////////////
bool TAutomovil::EsAutomatico()
{
return CAutomatico;
}

//////////////////////////////////////////////////////////
// Codificación del método Potencia de TAutomovil
//////////////////////////////////////////////////////////
int TAutomovil::Potencia()
{
return NPotencia;
}

//////////////////////////////////////////////////////////
// Codificación del constructor del tipo TCamion
//////////////////////////////////////////////////////////
TCamion::TCamion(short Cambios, bool Automatico, int Potencia): TVehiculo(3, 10, true)
{
NCambios = Cambios; // Preservar el resto de los datos
CAutomatico = Automatico;
NPotencia = Potencia;
}

//////////////////////////////////////////////////////////
// Codificación del método Nombre de TAutomovil
//////////////////////////////////////////////////////////
AnsiString TCamion::Nombre()
{
return "SemiRemolque";
}

//////////////////////////////////////////////////////////
// Codificación del método NumeroDeCambios de TAutomovil
//////////////////////////////////////////////////////////
short TCamion::NumeroDeCambios()
{
return NCambios;
}

//////////////////////////////////////////////////////////
// Codificación del método EsAutomatico de TAutomovil
//////////////////////////////////////////////////////////
bool TCamion::EsAutomatico()
{
return CAutomatico;
}

//////////////////////////////////////////////////////////
// Codificación del método Potencia de TAutomovil
//////////////////////////////////////////////////////////
int TCamion::Potencia()
{
return NPotencia;
}
#pragma package(smart_init)

Programa AdjuntoVehiculo.H
//////////////////////////////////////////////////////////
// C++ Builder APLICACION DE POLIMORFISMO
// Wilo Carpio Programa: Vehiculo.H
// DEFINICINES DE LAS CLASES
//////////////////////////////////////////////////////////
#ifndef VehiculoH
#define VehiculoH
//////////////////////////////////////////////////////////
// La clase TVehiculo será la base de todas
// las de más clases
//////////////////////////////////////////////////////////

class TVehiculo
{
//////////////////////////////////////////////
// DECLARACION de MIEMBROS Y METODOS
// public : Accesibles desde otros programas o módulos
// private : Accesibles solo desde el propio objeto
// protected: Accesibles desde objetos derivados y solo
// del mismo programa
/////////////////////////////////////////////////

private:
short NEjes, NRuedas;
bool TieneMotor;

public:

//////////////////////////////////////////////
// CONSTRUCTOR: Con tres parámetros
//////////////////////////////////////////////
TVehiculo(short Ejes, short Ruedas, bool Motor);

/////////////////////////////////////////////////////////
// FUNCION VIRTUAL ABSTRACTA: significa
// que no tiene implementación en esta clase, y
// tendrá que ser necesariamente implementada por
// los descendientes de TVehiculo
//////////////////////////////////////////////////////////
virtual AnsiString Nombre() = 0;

/////////////////////////////////////////////////////////
// Estas funciones son informativas, y servirán para
// obtener algunos datos del vehículo
/////////////////////////////////////////////////////////

short NumeroDeEjes();
short NumeroDeRuedas();
bool FuncionaConMotor();
};

//////////////////////////////////////////////////////////
// La clase TBicicleta está derivada de TVehiculo,
// heredando sus miembros y métodos
//////////////////////////////////////////////////////////
class TBicicleta : public TVehiculo
{
public:
TBicicleta(); // Constructor no necesita parámetros
AnsiString Nombre(); // Se redefine el método Nombre
};

//////////////////////////////////////////////////////////
// La clase TBicicletaMontana está derivada de TBicicleta
//////////////////////////////////////////////////////////
class TMountanBike : public TBicicleta
{
private:
short NCambios; // Número de cambios
public:
TMountanBike(short Cambios); // Constructor
AnsiString Nombre(); // Redefinimos el método Nombre
short NumeroDeCambios(); // Devuelve el número de cambios
};

//////////////////////////////////////////////////////////
// La clase TAutomovil está derivada de TVehiculo, y no
// de TBicicleta, abriendo así una nueva rama en la jerarquía
//////////////////////////////////////////////////////////
class TAutomovil : public TVehiculo
{
private:
short NCambios; // Número de cambios
bool CAutomatico; // Cambio automático
int NPotencia; // Potencia en caballos
public:

/////////////////////////////////////////////////////////
// El constructor recibe los datos adicionales necesarios
///////////////////////////////////////////////////////////

TAutomovil(short Cambios, bool Automatico, int Potencia);
AnsiString Nombre(); // Redefinimos el método nombre
short NumeroDeCambios(); // Y añadimos los métodos necesarios
bool EsAutomatico(); // para devolver el resto de los datos
int Potencia();
};

//////////////////////////////////////////////////////////
// La clase TCamion derivada de TVehiculo,
// abriendo así una nueva rama en la jerarquía
//////////////////////////////////////////////////////////
class TCamion : public TVehiculo
{
private:
short NCambios; // Número de cambios
bool CAutomatico; // Cambio automático
int NPotencia; // Potencia en caballos
public:
//////////////////////////////////////////////////////////
// El constructor recibe los datos adicionales necesarios
///////////////////////////////////////////////////////////
TCamion(short Cambios, bool Automatico, int Potencia);
AnsiString Nombre(); // Redefinimos el método nombre
short NumeroDeCambios(); // Y añadimos los métodos necesarios
bool EsAutomatico(); // para devolver el resto de los datos
int Potencia();
};
#endif