Herencia

Herencia

Ampliaciďż˝n utilizando la herencia

Redefiniciďż˝n utilizando la herencia.

Hasta aquďż˝ hemos visto como utilizan los objetos de una clase los recursos que en ella existen.

En la POO atraves de la herencia es posible que una clase herede de otra las propiedades y mďż˝todos de esta y no solo utilizarlos sino tambiďż˝n variarlos o aďż˝adirle nuevos.

Ampliaciďż˝n utilizando la herencia

Cuando queremos utilizar todo el contenido de una clase pero sin embargo no estďż˝n en ellas todas las operaciones que necesitamos podemos por la vďż˝a de la herencia aďż˝adir los elementos que necesitamos.

Tomemos para ejemplificar esto la clase TVector.

#include <iostream.h>
class TVector
{ private: int NrElementos;
             int *Elementos;
public : TVector (int NrEleP)
                   {NrElementos = NrEleP;
                    Elementos = new int[NrElementos];
                    }
int MiNrE() {return NrElementos;}
int MiElem(int nr)   {return Elementos[nr];}
void Llena(int Nr,int valor);
void Muestra();
TVector operator +(TVector X);
};

void TVector :: Llena(int Nr,int valor)
{ Elementos[Nr] = valor;
}
void TVector :: Muestra()
{ for (int i=0;i<NrElementos;i++)
    { cout << Elementos[i] << "\n";
    }
    cout << "\n";
}
TVector TVector :: operator + (TVector X)
{ TVector Temp(X.NrElementos);
int i = 0;
for (;i<NrElementos;i++)
      {Temp.Elementos[i] = Elementos[i] + X.Elementos[i];
      }
return (Temp);
}

Como vemos en la clase TVector que se muestra arriba, las funciones MiNrE() y MiElem(int nr) se definen e instrumetan dentro de la propia clase. De esta manera esas funciones serďż˝n expandidas en linea, esto es cada vez que se haga una llamada a ellas se reproducirďż˝ totalmente su cďż˝digo en el lugar donde se hace el llamado a la funciďż˝n. De esta manera el programa ganarďż˝ en velocidad pero tambiďż˝n aumentarďż˝ en tamaďż˝o.

Por su parte las funciones Llena(int Nr,int valor), Muestra() y operator +(TVector X) se instrumentan fuera de la clase. En este caso, como se ve, se antepone al nombre de la funciďż˝n el nombre de la clase seguido de :: En este caso, cuando se llamen estas funciones se realizarďż˝ una llamada normal a funciďż˝n, de manera que perderemos un cierto tiempo en el proceso de llamada pero el archivo del programa ser[a un poco menor.

En esta clase aparece el operador + redefinido, de manera que lo podremos usar como estamos acostumbrados a utilizarlo solo que ahora realizarďż˝ la operaciďż˝n de suma sobre vectores y no nďż˝meros como habitualmente se realiza.

En el programa "Vector1.cpp" que aparece a continuaciďż˝n se utiliza la clase TVector, realizandose en ďż˝l la suma de los objetos Vector1 y Vector2 para dar como resultado Vector3.

#include "vector1.h"

~ ~ ~ ~ ~

void main()

{ TVector Vector1(4),Vector2(4),Vector3(4);
for(int i=0;i<4;i++)
     {Vector1.Llena(i,i);
      Vector2.Llena(i,2*i);
     }
Vector3 = Vector1 + Vector2;
Vector3.Muestra();
getch();
}

En la clase TVector existe la posibilidad de tener un vector con cualquier cantidad de elementos, realizar la suma de vectores dos a dos siempre que estos tengan igual cantidad de elementos.

Si queremos tener ahora en una clase la posibilidad de realizar la resta de dos vectores y mantener al mismo tiempo todas las caracteristicas de Vector podemos utilizar la propiedad de la herencia y construir la clase TVector2

#include <Vector.h>
class TVector2 : public TVector
{ public : TVector2(int NrEleP) : TVector (NrEleP)
{}
TVector2 operator - (TVector X);
TVector2 operator = (TVector X);
};

TVector2 TVector2 :: operator - (TVector X)
{ TVector2 temp(MiNrE());
int i = 0;
for (;i<X.MiNrE();i++)
{temp.Llena(i,MiElem(i) - X.MiElem(i));
}
return (temp);
}

TVector2 TVector2 :: operator = (TVector X)
{ TVector2 Y(MiNrE());
for (int i=0;i<MiNrE();i++)
{Llena(i,X.MiElem(i));
}
return (Y);
}

Hemos agregado en esta clase el operador resta - y el de igualdad = y basandonos en que ella contiene las propiedades de aquella de la que hereda, en este caso TVector1, lo que se expresa sintaxticamente por:

class TVector2 : public TVector

no hemos tenido que volver a escribir el operador suma, ni ninguna de las otras propiedades o mďż˝todos que ya existian en aquella.

Podremos entonces ejecutar un programa Vector2.cpp

~ ~ ~ ~ ~

void main()
{ TVector2 Vector1(4),Vector2(4),Vector3(4);
for(int i=0;i<4;i++)
     {Vector1.Llena(i,i);
      Vector2.Llena(i,2*i);
     }
Vector3 = Vector1 - Vector2;
Vector3.Muestra();
Vector3 = Vector1 + Vector2;
Vector3.Muestra();
getch();
}

Como se ve los objetos Vector1, Vector2 y Vector3 de la clase TVector2 tienen la posibilidad de realizar las operaciones que estďż˝n contenidas en TVector y las nuevas aďż˝adidas a TVector2.

Redefiniciďż˝n utilizando la herencia.

Otra posiblidad de la herencia es modificar un recurso ya existente.

Consideremos que a la clase TVector1 queremos cambiarle la funciďż˝n Muestra() para que las letras ahora sean rojas.

Para ello definimos la clase TVector3 como aparece a continuaciďż˝n.

#include "vector1.h"

class TVector3 : public TVector

{ public : TVector3 (int NrEleP) : TVector (NrEleP)

{}

void Muestra();

};

void TVector3 :: Muestra()
{ textcolor(RED);
clrscr();
for (int i=0;i<MiNrE();i++)
{ cout << MiElem(i) << "\n";
}
cout << "\n";
}

Hemos asumido que la clase Vector1.h estďż˝ en el directorio actualmente abierto y por eso la ponemos entre "", si no es asďż˝ debe situarse como lo venimos haciendo entre <> y la direcciďż˝n donde debe buscarse debe aparece en el menďż˝ Options|directories.

Como vemos, en ella volvemos a definir y desarrollar una funciďż˝n Muestra(). De esta manera los objetos de la clase TVector3 utilizan esa funciďż˝n Muestra() aunque en la clase TVector exista otra con igual nombre.

Hosted by www.Geocities.ws