miércoles, 30 de septiembre de 2015

Clases Abstractas

Las clases abstractas sirven para proporcionar clase base, a partir las clases pueden heredan sus datos y funciones miembro. No se pueden generar objetos para este tipo de clases.
Cuando se hereda una clase abstracta, se tiene que implementar todas las funciones virtuales, o la clase que se hereda se convierte en una nueva clase abstracta

Ejemplo
Codificación CodeBlocks

#include <iostream>
using namespace std;
class Figura
{
public:
    virtual void dibujaFigura() ;
    virtual void nombreFigura() ;
    virtual double areaFigura()  ;
    virtual void mostrarDatosFigura() ;
};
void Figura::nombreFigura()
{}
double Figura::areaFigura()
{ }
void Figura::mostrarDatosFigura() { }
class Rectangulo:public Figura
{
    protected:
    double largo;
    double ancho;
    public:
        Rectangulo();
        Rectangulo(double, double);
        virtual void dibujaFigura() ;
        virtual void nombreFigura() ;
        virtual double areaFigura() ;
        virtual void mostrarDatosFigura() ;
};
Rectangulo::Rectangulo()
{
    largo=0;
    ancho=0;
}
Rectangulo::Rectangulo(double la,double an)
{
    largo=la;
    ancho=an;
}
 void Rectangulo::dibujaFigura()
{
    cout<<"\t********************\n";
    cout<<"\t*                                    *\n";
    cout<<"\t*                                    *\n";
    cout<<"\t*                                    *\n";
    cout<<"\t********************\n";
}
 void Rectangulo::nombreFigura()
 {
    cout<<"\tRECTANGULO\n\n";
}
double Rectangulo::areaFigura()
{
    return largo*ancho;
}
void Rectangulo::mostrarDatosFigura()
 {
    cout<<"\tDatos Rectangulo\n";
    cout<<"\tLargo = "<<largo<<endl;
    cout<<"\tAncho = "<<ancho<<endl;
    cout<<"\tArea = "<<areaFigura()<<endl;
}
int main()
{
   Rectangulo r1(20,10);
   r1.nombreFigura();
   r1.dibujaFigura();
   r1.mostrarDatosFigura();
    return 0;
}

Constructores y destructores en clases derivadas

Sabemos que una clase derivada hereda los miembros de su clase base, en tal forma cuando se crea un objeto de la clase derivada, se necesita llamar al constructor de la clase base, para inicializar los miembros de la clase base del objeto de la clase derivada.
Los constructores de la clase base  no se heredan a  las clases derivadas, pero  la clase derivada pueden llamar a los constructores de la clase base.
Los operadores de  asignacion tampoco se heredan a la clase derivada, pero tambien pueden llamarse en la clase derivada.
Un constructor de la clase derivada llamará primeramente al constructor de la clase base, para inicializar los miembros de la clase base que corresponden a la clase derivada.
Los destructores se llaman primero de la clase derivada y después al clase base.

Ejemplo
Codificación CodeBlocks

#include <iostream>
using namespace std;
class Primera
{
protected:
    int a;
public:
    Primera();
    ~Primera();
    void establecerA(int);
    int obtenerA();
    virtual void mostrar();
};
Primera::Primera()
{
    a=10;
    cout<<"Constructor clase Base\n\n";
}
Primera::~Primera()
{
    cout<<"Destructor clase Base\n\n";
}
void Primera::establecerA(int x)
{
    a=x;
}
int Primera::obtenerA()
{
    return a;
}
void Primera::mostrar()
{
    cout<<"El valor de a es "<<a<<endl<<endl;
}
class Segunda: public Primera
{
protected:
    double b;
public:
    Segunda(int,double);
    ~Segunda();
    void establecerB(double );
    double obtenerB();
    virtual void mostrar();
};
Segunda::Segunda(int x, double y)
{
    cout<<"a= "<<a<<endl;
    a=x;
    b=y;
    cout<<"Constructor de la derivada\n\n";
}
Segunda::~Segunda()
{
    cout<<"Destructor de clase derivada\n\n";
}
void Segunda::establecerB(double x)
{
    b=x;
}
double Segunda::obtenerB()
{
    return b;
}
void Segunda::mostrar()
{
    cout<<"despliegue de los datos de la clase derivada\n";
    cout<<" a= "<<a<<endl;
    cout<<" b= "<<b<<endl;
}
int main()
{
    Segunda s(7,4.0);
    s.mostrar();

    return 0;
}

lunes, 28 de septiembre de 2015

Polimorfismo

El polimorfismo permite que un mismo nombre de una función se comporte diferente en una clase base  y una clase derivada. Sucede que existe una anulación de la función miembro de la clase base ,usando la sobrecarga en una funcion miembro de la clase derivada. El uso de funciones virtuales permiten este comportamiento dependiendo que objeto lo invoca.

Ejemplo:
Codificación Codeblocks

#include <iostream>
using namespace std;
class Figura
{
public:
    virtual double area();
    virtual void imprimeNombreFigura();
    virtual void imprimeFigura();
};
double Figura::area()
{
    return 0.0;
}
void Figura::imprimeFigura()
{
    cout<<" \n";
}
void Figura::imprimeNombreFigura()
{
    cout<<"   \n";
}
class Circulo: public Figura
{
protected:
    double radio;
public:
    Circulo(double );
    void estRadio(double);
    double obtenerRadio();
    virtual double area();
    virtual void imprimeNombreFigura();
    virtual void imprimeFigura();
};
Circulo::Circulo(double rad)
{
    radio=rad;
}
 void Circulo::estRadio(double r)
 {
     radio=r;
 }
 double Circulo::obtenerRadio()
 {
     return radio;
 }
 double Circulo::area()
 {
     return 3.1416*radio*radio;
 }
void Circulo::imprimeNombreFigura()
{
    cout<<"Figura : CIRCULO\n\n";
}
void Circulo::imprimeFigura()
{
    cout<<"       *"<<endl;
    cout<<"    *     *"<<endl<<endl;
    cout<<"   *        *"<<endl<<endl;
    cout<<"    *     *"<<endl;
   cout<<"       *"<<endl;
}
int main()
{
    Figura f1;
    Circulo c1(25.00);
    c1.imprimeNombreFigura();
    c1.imprimeFigura();
    cout<<"Datos: \n";
    cout<<"Radio: "<<c1.obtenerRadio()<<endl;
    cout<<"Area: "<<c1.area()<<endl;

    return 0;
}

jueves, 24 de septiembre de 2015

Ejercicio 9 Herencia

Cree una clase base llamado punto que consiste de una coordenada x y una coordenada y. A partir de esta clase derive una clase llamada Circulo que tenga un miembro de datos adicional llamado radio. Para esta clase derivada los miembros x y y representan las coordenadas del centro de un circulo. Los miembros de la function de la primera clase deberán consistir de un constructor, una function area llamada area que devuelva cero y una function de distancia que devuelva la distancia entre dos puntos, donde distancia = raiz cuadrada sqrt((x2-x1)^2 +(y2-y1)^2))
Además, la clase derivada deberá tener un constructor y una function que lo anule llamada area que devuelva el area del circulo.
Problema propuesto del Libro C++ para ingenieria y ciencias Gary J. Brinson ejercicios 10.6 problema 5 pag. 592

Codificación CodeBlocks

#include <iostream>
#include <cmath>
using namespace std;
class Punto
{
protected:
    int x;
    int y;
public:
    Punto(int =0, int=0);
    void estXY(int,int);
    void estableceX(int);
    void estableceY(int);
    int obtenerX();
    int obtenerY();
  virtual  double area();
    double distancia (Punto ,Punto);
};
Punto::Punto(int px, int py)
       {
          x=px;
          y=py;
       }
void Punto::estXY(int px,int py)
{
    x=px;
    y=py;
}
void Punto::estableceX(int px)
{
    x=px;
}
void Punto::estableceY(int py)
{
    y=py;
}
int Punto::obtenerX()
{
    return x;
}
 int Punto::obtenerY()
{
    return y;
}
double Punto::area()
{
    return 0;
}
double Punto::distancia(Punto a, Punto b)
{
    int px1,px2,py1,py2;
    double res,dist;
    px1=a.obtenerX();
    px2=b.obtenerX();
    py1=a.obtenerY();
    py2=b.obtenerY();
    res=pow((px2-px1),2)+ pow((py2-py1),2);
    dist=sqrt(res);
    return dist;
}
class Circulo:public Punto
{
    protected:
    double radio;
    public:
        Circulo(double =1.0, int =0, int =0);
       void estRadio(double r);
       double obtenerRadio();
      virtual double area();
};
Circulo::Circulo(double rad,int px,int py)
{
    radio=rad;
    x=px;
    y=py;
}
void Circulo:: estRadio(double r)
{
    radio=r;
}
double Circulo::obtenerRadio()
{
    return radio;
}
 double Circulo::area()
{
    return 3.1416*radio*radio;
}
int main()
{
    Punto p1(4,5);
    Punto p2(8,10);
    Circulo c1;
    c1.estRadio(10);
cout<<"Area Circulo es : "<<c1.area()<<endl;
cout<<"El area del punto 1 es "<<p1.area()<<endl;
cout<<"La distancia entre Punto 1 y punto 2 es : "<<c1.distancia(p1,p2)<<endl;

    return 0;
}

Ejercicio 8 herencia

Hacer una clase circulo cuyo dato miembro es radio y crear un constructor y una función miembro para calcular el área. y incluir una clase derivada esfera a partir de la clase circulo solo debe agregar un constructor y una función miembro  para calcular el volumen de la esfera.

Codificacion CodeBlocks

#include <iostream>
#include <cmath>
using namespace std;
class Circulo
{
protected:
    double radio;
public:
    Circulo(double = 1.0);
    void establecerRadio(double );
    double calcArea();
};
Circulo::Circulo(double r)
{
    radio=r;
}
void Circulo::establecerRadio(double rad)
{
    radio=rad;
}
double Circulo::calcArea()
{
    return 3.1416*radio*radio;
}
class Esfera:Circulo
{
public:
    Esfera(double r);
    double calcVol();
};
Esfera::Esfera(double r)
{
    radio=r;
}
double Esfera::calcVol()
{
    return (4.0/3.0)*3.1416*pow(radio,3);
}
int main()
{
    double rad;
    cout<<"Introduce el radio de la esfera : ? ";
    cin>>rad;
    Esfera e1(rad);
    cout<<"Volumen de la esfera es "<<e1.calcVol()<<endl;
    return 0;
}

miércoles, 23 de septiembre de 2015

Herencia de clase

La herencia consiste en la capacidad para crear nuevas clases a partir de clases existentes.
La herencia permite la reutilización de software en la cual las nuevas clases heredan datos y funciones miembro de una clase que se denomina clase base(padre o superclase). La nueva clase se llama la clase derivada (hija o subclase).
C++ permite solo la herencia simple cada clase derivada solo contiene una clase base.
Los accesos en una clase, cuando el acceso private ( privado) de una clase base, solo podran tener acceso por medio de las funciones  miembros o amigas de la clase.
 Los miembros public  de una clase base  son accesibles para todas las funciones en el programa.
El acceso protected (protegido) de la clase base mediante funciones miembros y amigas de la clase base y también por la clase derivada.

class nombreClaseDerivada: accesoClase  nombreClaseBase

{
// se heredan los datos y funciones miembro de circulo
//se agregan los datos adicionales y funciones miembro
};


Miembro de la    Acceso de la         Miembro de la
clase base            clase derivada       clase derivada

protected            public                   protected
public                 protected              protected
public                 public                   public
public                 protected              protected
protected            protected              protected
protected            private                  private
private                private                  no se puede accesar
private                public                   no se puede accesar
private                protected              no se puede accesar


Ejemplo CodeBlocks

#include <iostream>
using namespace std;
class Uno
{
protected:
    int x;
public:
    Uno(int =1);
    void estUno(int x);
    int obtenerUno();
    void mostrarUno();
};
Uno::Uno(int val)
{
  x=val;
}
void Uno::estUno(int val)
{
    x=val;
}
int Uno::obtenerUno()
{
    return x;
}
void Uno::mostrarUno()
{
    cout<<" x= "<<x<<endl;
}
class Dos:public Uno
{
protected:
    int y;
    public:
    Dos(int =1, int =1);
    void estDos(int ,int);
    int obtenerDos();
    void mostrarDos();
};
Dos::Dos(int val,int val2)
{
  x=val;
  y=val2;
}
void Dos::estDos(int val,int val2)
{
    x=val;
    y=val2;
}
int Dos::obtenerDos()
{
    return y;
}
void Dos::mostrarDos()
{
    cout<<"\n\nX= "<<x<<endl;
    cout<<"Y="<<y<<endl;
}

int main()
{
    Uno obj1(1);
    obj1.estUno(10);
    obj1.mostrarUno();
    Dos obj2(2,3);
    obj2.mostrarDos();

    return 0;
}

sábado, 19 de septiembre de 2015

Ejercicio 7 con sobrecarga de operadores

Considere la clase complejo que permita operaciones de números complejos suma, resta, multiplicacion, asignacion, igual o diferente, utilizando sobrecarga de operadores.

Codificación CodeBlocks

#include <iostream>
using namespace std;
class Complejo
{
private:
    double real;
    double imaginario;
public:
    Complejo (double =1.0, double =1.0);
    Complejo operator+(const Complejo &)const;
    Complejo operator-(const Complejo &)const;
    Complejo operator*(const Complejo &)const;
    const Complejo &operator=(const Complejo &);
    int operator==(const Complejo &)const;
    void mostrarComplejo()const;
};
Complejo::Complejo(double r, double ima)
{
    real=r;
    imaginario=ima;
}
Complejo Complejo::operator+ (const Complejo &c1)const
{
    double cr,ci;
    cr=real + c1.real;
    ci=imaginario+c1.imaginario;
    return Complejo(cr,ci);
}
Complejo Complejo::operator- (const Complejo &c1)const
{
    double cr,ci;
    cr=real - c1.real;
    ci=imaginario - c1.imaginario;
    return Complejo(cr,ci);
}
Complejo Complejo::operator* (const Complejo &c1)const
{
    double cr,ci;
    cr=(real * c1.real )- (imaginario*c1.imaginario) ;
    ci=(real*c1.imaginario) + (c1.real *imaginario);
    return Complejo(cr,ci);
}
const Complejo& Complejo:: operator=(const Complejo &c1)
{
    real=c1.real;
    imaginario=c1.imaginario;
    return *this;
}
int Complejo::operator==(const Complejo &c1)const
{
    if (real==c1.real && imaginario==c1.imaginario)
        return 1;
    else 0;
}
void Complejo::mostrarComplejo()const
{
    cout<<"( "<<real<<" , "<<imaginario<<" ) "<<endl;
}
int main()
{
    int b;
    Complejo x,y(2.0,8.0),z(5.0,3.0);
    cout<<"\nComplejo Y : ";
    y.mostrarComplejo();
    cout<<"\nComplejo Z : ";
    z.mostrarComplejo();
    x=y+z;
    cout<<"\nLa suma de los complejos Y + Z : ";
    x.mostrarComplejo();
    x=y-z;
    cout<<"\nLa resta de los complejos Y - Z : ";
    x.mostrarComplejo();
    x=y*z;
    cout<<"\nLa multiplicacion de los complejos Y * Z: ";
    x.mostrarComplejo();
    b=y==z;
    if(b==1)
        cout<<"\nEl numero Complejo Y es igual numero Complejo Z\n";
    else
        cout<<"\nEl numero Complejo Y es diferente al numero Complejo Z\n";

    return 0;
}