Clase 3 HERENCIA Y AMISTAD

Herencia simple

Es la más típica, la que se puede encontrar en cualquier lenguaje moderno. Es

una relación entre una clase padre (clase base) y una clase hija (clase derivada)
llamada "es un tipo de". Cuando la clase derivada que estamos considerando sólo
tiene una clase base.

Un ejemplo sería el siguiente:

#include <iostream>
using namespace std;

class Vehiculo {
public:
void avanza() {}
};

class Coche : public Vehiculo {

public:
void avanza(void)
{ cout << "Avanza coche." << endl; }
};

class Moto: public Vehiculo {

public:
void avanza(void)
{ cout << "Avanza moto." << endl; }
};

int main()
{
Moto t;
Coche c;

t.avanza();
c.avanza();

return 0;
}
Herencia múltiple

Se encuentra en aquellos casos en los que una clase derivada tiene varias clases
base (al menos, más de una). Un ejemplo sería una clase ProfesorUniversitario
que heredara de las clases Profesor e Investigador.
La clase Profesor declararía la información que deseamos conocer sobre los
profesores: su nombre y la materia que imparten.

class Profesor {
private:
string nombre;
string materia;
public:
Profesor(const string &n, const string &m) : nombre( n ), materia( m )
{}
const string &getNombre() const
{ return nombre; }
const string &getMateria() const
{ return materia; }
};

La clase Investigador declararía la información que deseamos conocer sobre los

investigadores: su nombre y la especialidad en la que investigan.

class Investigador {
private:
string nombre;
string especialidad;
public:
Investigador (const string &n, const string &e) : nombre( n ),
especialidad( e )
{}
const string &getNombre() const
{ return nombre; }
const string &getEspecialidad() const
{ return especialidad; }
};

La forma de crear la clase mediante herencia múltiple sería la siguiente:

class ProfesorUniversitario : public Profesor, public Investigador {
public:
ProfesorUniversitario(const string &n, const string &e, const string
&m)
: public Profesor( n, m ), public Investigador( n, e )
{}
};

No es necesario nada más en la clase ProfesorUniversitario, ya que todo lo que

necesita, viene dado por las clases superiores. Se visualiza la información de un
ProfesorUniverstiario de la siguiente manera:
int main()
{
ProfesorUniversitario p( "Baltasar", "Máquinas Virtuales", "Tecnología
de Objetos" );

cout << p.getNombre() << ','

<< p.getMateria() << ','
<< p.getEspecialidad() << endl
;
}

El programa anterior tiene defectos, el manejo que realiza de la memoria es

ineficiente. Esto es debido a que hay dos atributos nombre que se emplean en
ProfesotrUniversitario, el heredado de Investigador y el heredado de Profesor.

No compila, ya que al se trata de compilar p.getNombre() ... ¡no sabe cuál

utilizar! ... ¿Investigador o Profesor? La forma de solucionarlo sería cualificar el
método a invocar con el nombre de la clase, por ejemplo:
p.Investigador::getNombre()

Herencia privada

Herencia en la que todos los miembros públicos y protegidos de la clase basen

adquieren el nivel de acceso privado en las clases derivadas. De ahí se desprende
que una clase derivada que haya heredado mediante herencia privada no puede
heredar a otras clases los miembros que ha heredado de otras clases.

class ClaseDerivada : private ClaseBase

Clases amigas

La “amistad” es una característica que permite que una función que no pertenece
a una clase en particular, pueda hacer uso de sus métodos. Los métodos amigos
de una clase no pertenecen a ella, pero se les permite el acceso a sus miembros
privados y protegidos.

Métodos amigos

Estos “métodos amigos” a veces permiten aumentar el rendimiento del programa.

La palabra clave “friend” es un especificador de acceso utilizado para declarar que
una función o clase, tiene derecho de acceso a los miembros de la clase en que
se declara, sin que la clase invitada tenga que ser miembro de la anfitriona.

Funciones Amigas

Una función amiga es una función que se define fuera de una clase pero que tiene
derecho a acceder a los miembros privados y protegidos de ella. Para que una
función sea amiga de una clase, y por consiguiente tenga acceso a todos sus
métodos, primero se define un prototipo de esa función dentro de la clase, y se
antepone a dicha definición la palabra “friend”. Además de esto, es necesario que
a la función amiga se le pase como parámetro un objeto de la clase de la cual es
amiga.

Ejemplo:

Crear una clase llamada Temperatura que permita inicializar la temperatura

mínima, máxima y actual. Definir una función amiga que reciba dos objetos de la
clase Temperatura y retorne la temperatura promedio actual.

#include<iostream>
using namespace std;
class Temperatura {
int minima, maxima, actual;
public:
Temperatura(int min, int max, int act){ minima = min; maxima = max; actual = act; }
friend int temperaturaMedia(Temperatura t1, Temperatura t2);
};
int temperaturaMedia(Temperatura t1, Temperatura t2){
int pro =(t1.actual + t2.actual)/2;

return pro;
}
int main(){
Temperatura temperatura1(10, 20, 15);
Temperatura temperatura2(12, 25, 17);
cout << "La temperatura promedio de las temperaturas actuales es: ";
cout << temperaturaMedia(temperatura1, temperatura2)<<endl;
return 0;
}
Ejercicios:

1.- Usando herencia. Se necesita implementar dos clases llamadas Suma y Resta.
Cada clase tiene como atributo valor1, valor2 y resultado.
Las propiedades a definir son Valor1, Valor2 y Resultado
El método Operar (que en el caso de la clase "Suma" suma los dos Valores y en el caso de la
clase "Resta" hace la diferencia entre Valor1 y Valor2.)

Solucion

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Herencia
{

    public class Operacion
    {
        protected int valor1;
        protected int valor2;
        protected int resultado;

        public int Valor1
        {
            set
            {
                valor1 = value;
            }
            get
            {
                return valor1;
            }
        }

        public int Valor2
        {
            set
            {
                valor2 = value;
            }
            get
            {
                return valor2;
            }
        }

        public int Resultado
        {
            protected set
            {
                resultado = value;
            }
            get
            {
                return resultado;
            }
        }
    }

    public class Suma : Operacion
    {
        public void Operar()
        {
            Resultado = Valor1 + Valor2;
        }
    }

    public class Resta : Operacion
    {
        public void Operar()
        {
            Resultado = Valor1 - Valor2;
        }
    }

    class Prueba
    {
        static void Main(string[] args)
        {
            Suma suma1 = new Suma();
            suma1.Valor1 = 10;
            suma1.Valor2 = 7;
            suma1.Operar();
            Console.WriteLine("La suma de " + suma1.Valor1 + " y " +
              suma1.Valor2 + " es " + suma1.Resultado);
            Resta resta1 = new Resta();
            resta1.Valor1 = 8;
            resta1.Valor2 = 4;
            resta1.Operar();
            Console.WriteLine("La diferencia de " + resta1.Valor1 +
              " y " + resta1.Valor2 + " es " + resta1.Resultado);
            Console.ReadKey();
        }
    }
}

Al ejecutar el código muestra el siguiente resultado