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;
}

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;
}

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;
}

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;
}

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;
}

Sobrecarga de operadores

C++ permite sobrecargar los operadores escribiendo una función con la palabra reservada operator, seguida por el simbolo del operador que va sobrecargar por ejemplo : el operador de suma (+).
Para utilizer un operador sobre objetos de clases, el operador debe sobrecargarse, existen dos excepciones en operadores que no necesitan sobrecargarse el de asignacion (=) y el operador de direccion &.
 No se pueden crearse operadores nuevos, un operador unario no puede cambiarse por un operador binario y un operador binario a operador unario.
El operador debe ser miembro de una clase.

Ejemplo:
Codificacion CodeBlocks

#include <iostream>
#include <iomanip>
using namespace std;
class Fecha
{
private:
    int dia;
    int mes;
    int anio;
public:
    Fecha(int =9,int =9,int =1900);
    void estFecha(int,int,int);
    void asignarDia(int);
    void asignarMes(int);
    void asignarAnio(int);
    int obtenerDia();
    int obtenerMes();
    int obtenerAnio();
    Fecha operator+(int);
    void mostrarFecha();
};
Fecha::Fecha(int d, int m,int a)
{
    dia=d;
    mes=m;
    anio=a;
}
void Fecha::estFecha(int d,int m,int a)
{
    dia=d;
    mes=m;
    anio=a;
}
void Fecha::asignarDia(int d)
{
    dia=d;
}
void Fecha::asignarMes(int m)
{
    mes=m;
}
void Fecha::asignarAnio(int a)
{
    anio=a;
}
int Fecha::obtenerDia()
{
    return dia;
}
int Fecha::obtenerMes()
{
    return mes;
}
int Fecha::obtenerAnio()
{
    return anio;
}
Fecha Fecha::operator+(int dias)
{
    Fecha aux;
    aux.dia=dia+dias;
    aux.mes=mes;
    aux.anio=anio;
    while(aux.dia>30)
    {
        aux.mes++;
        aux.dia -=30;
    }
    while(aux.mes>12)
    {
        aux.anio++;
        aux.mes -=12;
    }
    return aux;
}
void Fecha::mostrarFecha()
{
    cout<<setw(2)<<dia<<"/"<<setw(2)<<mes<<"/"<<setw(4)<<anio<<endl;
}

int main()
{
    Fecha f1(20,1,2010),f2;
    cout<<"Fecha es : ";
    f1.mostrarFecha();
    f2=f1 + 366;
    cout<<"ahora la fecha es : ";
    f2.mostrarFecha();
    return 0;
}

Ejercicio 6 Clases con miembros estaticos

Elabore la clase CuentaAhorros. Utilice un dato miembro estático que contenga la tasaInteresAnual de cada uno de los ahorradores. Cada miembro de la clase debe contener un dato miembro privado saldoAhorro que indique el monto que el ahorrador tiene en deposito. Proporcione una función miembro ultimoInteresMensual que calcule el interés mensual al multiplicar el saldo por tasaInteresAnual dividida entre 12; este interés debe sumarse a saldoAhorro. Proporcione una función miembro estática modificaTasaInteres que establezca el Nuevo valor de tasaInteresAnual. Escriba un programa principal que pruebe el funcionamiento de CuentaAhorros. Genere dos instancias de objetos CuentaAhorros, ahorrador1, ahorrador2 con saldos de $2000.00 y $3000.00 respectivamente.Establezca tasaInteresAnual en 4% y calcule el interés del mes siguiente e imprima los nuevos saldos para cada uno de los ahorradores.
Problema propuesto por el libro C/C++ y Java Cómo Programar Cuarta Edición Deitel pag.601-17.8

Codificación CodeBlocks

#include <iostream>
using namespace std;
class CuentaAhorros
{
    private:
    double saldoAhorro;
    static double tasaInteresAnual;
    public:
        CuentaAhorros(double);
        CuentaAhorros();
        void estSaldoAhorro(double);
        double obtenerSaldoAhorro();
        void ultimoInteresAnual();
     static void  modificaTasaInteres(double tasa);
        void imprimeSaldo();
};
CuentaAhorros::CuentaAhorros(double saldo)
{
    saldoAhorro=saldo;
}
CuentaAhorros::CuentaAhorros()
{
    saldoAhorro=0.0;
}
void CuentaAhorros::estSaldoAhorro(double saldo)
{
    saldoAhorro=saldo;
}
double CuentaAhorros::obtenerSaldoAhorro()
{
    return saldoAhorro;
}
void CuentaAhorros::ultimoInteresAnual()
{
    double interesMensual;
    interesMensual=(saldoAhorro*tasaInteresAnual)/12.0;
    saldoAhorro=saldoAhorro + interesMensual;
}
double CuentaAhorros::tasaInteresAnual=0.03;
 void CuentaAhorros::modificaTasaInteres(double tasa)
{
   tasaInteresAnual= tasa;
}
void CuentaAhorros::imprimeSaldo()
{
    cout<<"Saldo: "<<saldoAhorro<<endl;
}
int main()
{
    CuentaAhorros ahorrador1(2000.00), ahorrador2(3000.00);
    cout<<"Tasa Interes Anual : 0.03\n";
    cout<<"\nAhorrador 1\n";
    ahorrador1.ultimoInteresAnual();
    ahorrador1.imprimeSaldo();
    cout<<"\nAhorrador 2\n";
    ahorrador2.ultimoInteresAnual();
    ahorrador2.imprimeSaldo();
    CuentaAhorros::modificaTasaInteres(0.04);
    ahorrador1.ultimoInteresAnual();
    cout<<"\n\nTabla Interes Anual: 0.04\n";
    cout<<"\nAhorrador 1\n";
    ahorrador1.imprimeSaldo();
    cout<<"\nAhorrador 2\n";
    ahorrador2.ultimoInteresAnual();
    ahorrador2.imprimeSaldo();
    return 0;
}

Clases miembro static

Cuando se crea un objeto de una clase tiene su propio bloque de memoria, pero en ocasiones es necesario que cada objeto de una clase compartan la misma ubicación de memoria por medio  de una variable estatica.
 Una variable de  estatica de una clase representa información interna de la clase, no de un objeto especifico. Estos datos Deben inicializarse solo una vez.

Ejemplo

class Empleado
{
private:
  int idEmpleado;
  string nombreEmpleado;
  static double impuesto;  // esta es la variable comun para todos los objetos de la clase
  public
  Empleado( );
  Empleado(int, string);
 void mostrarDatosEmpleado( );
static void modificaImpuesto(double); 
};

Apuntador this

El apuntador this se utiliza para que un objeto tenga acceso  a su propia dirección. El apuntador this se utiliza para hacer referencia a los datos miembro y a sus funciones miembro.


Codificacion en CodeBlocks

#include <iostream>
using namespace std;
class Circulo
{
private:
    double radio;
    friend void estRadio(Circulo &, double rad);
public:
    Circulo(double rad);
    Circulo();
    void estableceRadio(double rad);
    double areaCirculo();
    void imprimeDatosCirculo();
    double obtenerRadio() const;
    void imprimeInfCirculo()const;
};
Circulo::Circulo(double rad)
{
  radio=rad;
}
Circulo::Circulo()
{
    radio=0;
}
void Circulo::estableceRadio(double rad)
{
    radio=rad;
}
double Circulo::areaCirculo()
{
    return 3.1416*radio*radio;
}
void Circulo::imprimeDatosCirculo()
{
    cout<<"\n\nDatos del circulo\n";
    cout<<"Radio: "<<radio<<endl;
    cout<<"Area: "<<areaCirculo()<<endl;
}
double Circulo::obtenerRadio() const
{
    return radio;
}
void Circulo::imprimeInfCirculo() const
{
    double const r=this->obtenerRadio();    //acceso con this
cout<<"\n\nRadio : "<<this->obtenerRadio()<<endl;
    cout<<"Area: "<<(3.1416*r*r)<<endl;
}
void estRadio(Circulo &c, double val)
{
    c.radio=val;
}
int main()
{
    Circulo c1;
    const Circulo c2(45.0);
    estRadio(c1,15.0);
    c1.imprimeDatosCirculo();
    c1.estableceRadio(10);
    c1.imprimeDatosCirculo();
    c2.imprimeInfCirculo();

    return 0;
}

Objetos y funciones miembro const

Asi como existen datos constants que no se pueden modificar,tambien existen objetos y datos miembro que al utilizer la palabra reservada const esspecifica que un objeto no se puede modificar y si se intent modificar el compilador genera un error de sintaxis.

Ejemplo

#include <iostream>
using namespace std;
class Circulo
{
private:
    double radio;
    friend void estRadio(Circulo &, double rad);
public:
    Circulo(double rad);
    Circulo();
    void estableceRadio(double rad);
    double areaCirculo();
    void imprimeDatosCirculo();
    double obtenerRadio() const;
    void imprimeInfCirculo()const;
};
Circulo::Circulo(double rad)
{
    radio=rad;
}
Circulo::Circulo()
{
    radio=0;
}
void Circulo::estableceRadio(double rad)
{
    radio=rad;
}
double Circulo::areaCirculo()
{
    return 3.1416*radio*radio;
}
void Circulo::imprimeDatosCirculo()
{
    cout<<"\n\nDatos del circulo\n";
    cout<<"Radio: "<<radio<<endl;
    cout<<"Area: "<<areaCirculo()<<endl;
}
double Circulo::obtenerRadio() const
{
    return radio;
}
void Circulo::imprimeInfCirculo() const
{
    double const r=obtenerRadio();
    cout<<"\n\nRadio: "<<obtenerRadio()<<endl;
    cout<<"Area: "<<(3.1416*r*r)<<endl;
}
void estRadio(Circulo &c, double val)
{
    c.radio=val;
}
int main()
{
    Circulo c1;
    const Circulo c2(45.0);  // se declara el objeto c2 como constante
    estRadio(c1,15.0);
    c1.imprimeDatosCirculo();
    c1.estableceRadio(10);
    c1.imprimeDatosCirculo();
    c2.imprimeInfCirculo();    // la function miembro debe ser const

    return 0;
}

Funcion friend (funcion amiga) Ejemplo

Una function friend de una clase se define fuera de la clase, pero tiene derecho accesar a los datos privados de la clase. Las funciones amiga no son funciones miembro de la clase.
Las funciones amiga permite que el ocultamiento de información sea  eliminado, porque pueden modificar un dato privado.

Codificacion CodeBlocks

#include <iostream>
using namespace std;
class Circulo
{
private:
    double radio;
    friend void estRadio(Circulo &, double rad);  //prototipo function amiga
public:
    Circulo(double rad);
    Circulo();
    void estableceRadio(double rad);
    double areaCirculo();
    void imprimeDatosCirculo();
};
Circulo::Circulo(double rad)
{
    radio=rad;
}
Circulo::Circulo()
{
    radio=0;
}
void Circulo::estableceRadio(double rad)
{
    radio=rad;
}
double Circulo::areaCirculo()
{
    return 3.1416*radio*radio;
}
void Circulo::imprimeDatosCirculo()
{
    cout<<"\n\nDatos del circulo\n";
    cout<<"Radio: "<<radio<<endl;
    cout<<"Area: "<<areaCirculo()<<endl;
}
void estRadio(Circulo &c, double val)  //implementacion de function amiga
{
    c.radio=val;
}
int main()
{
    Circulo c1;
    estRadio(c1,15.0);   //acceso al objeto c1 para dar el valor del radio
    c1.imprimeDatosCirculo();
    c1.estableceRadio(20.5);
    c1.imprimeDatosCirculo();
    return 0;
}

Ejercicio 5 Clases y constructores

Crear una clase Rectangulo debe almacenarse las coordenadas cartesianas de las cuatro esquinas del rectangulo. El constructor llama una función establecer que acepta cuatro coordenadas y verifica que cada una  de éstas se  encuentren en el primer cuadrante y que ninguna coordenada x o y sea mayor que 20. La función establecer verifica también que las coordenadas proporcionadas forman un rectangulo. Proporcione funciones miembro que calcule la largo, el ancho, el perímetro y el área.

codificación CodeBlocks

#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
class Coordenada
{
    private:
    int x;
    int y;
    public:
    Coordenada(int =0, int y=0);
    void estXY(int ,int );
    void estX(int );
    void estY(int );
    int obtenerX();
    int obtenerY();
    int verificaX();
    int verificaY();
    void imprimeCoordenada();
};
Coordenada::Coordenada(int pX, int pY)
{
   x=pX;
   y=pY;
}
void Coordenada::estXY(int pX, int pY)
{
    x=pX;
    y=pY;
}
void Coordenada::estX(int pX)
{
    x=pX;
}
void Coordenada::estY(int pY)
{
    y=pY;
}
int Coordenada::obtenerX()
{
    return x;
}
int Coordenada::obtenerY()
{
    return y;
}
int Coordenada::verificaX()
{
    if (x>=0 && x<=20)
        return 1;
    else
        return 0;
}
int Coordenada::verificaY()
{
    if(y>=0 && y<=20)
    return 1;
else
    return 0;
}
void Coordenada::imprimeCoordenada()
{
    cout<<"La coordenada es "<<"( "<<x<<","<<y<<" )"<<endl;
}
class Rectangulo
{
private:
    Coordenada c1[4];
    int x;
    int ancho;
    int largo;
public:
    Rectangulo(Coordenada c1[4]);
   int establecer ();
   void estAncho(int);
   void estLargo(int);
   Coordenada obtenerCoordenas();
   int obtenerValor();
   int obtenerAncho();
   int obtenerLargo();
   int area();
   int perimetro();
};
Rectangulo::Rectangulo(Coordenada c1[4])
{
    x=establecer();
}
int Rectangulo::establecer( )
{
    int puntoX, puntoY,i;
    cout<<"Recuerde las coordenadas deben estar en el primer cuadrante\nlos valores debes >=0 y <=20\n\n";
    for(i=0;i<=3;i++)
    {
     if(i==0)
     {
       cout<<"(x,y)________\n";
       cout<<"|            |\n";
       cout<<"|___________ |\n";
     }
     else
     {
       if(i==1)
     {
       cout<<" ________(x,y)\n";
       cout<<"|            |\n";
       cout<<"|___________ |\n";
     }
      else
      {
          if(i==2)
     {
       cout<<" __________\n";
       cout<<"|           |\n";
       cout<<"|(x,y)______|\n";
     }
     else
     {
      if(i==3)
     {
       cout<<" ____________\n";
       cout<<"|            |\n";
       cout<<"|_______(x,y)|\n";
     }
    }
   }
  }
    do
    {
      cout<<"\nIntroduce la coordenada "<<i+1<<"  del rectangulo:\n";
      cout<<" X : ? ";
      cin>>puntoX;
      c1[i].estX(puntoX);
    }
    while (c1[i].verificaX()==0);
    do
    {
     cout<<" Y : ? ";
     cin>>puntoY;
     c1[i].estY(puntoY);
    }
    while(c1[i].verificaY()==0);
}
cout<"\n\nLas coordenadas son\n";
for(i=0;i<=3;i++)
    c1[i].imprimeCoordenada();
if((c1[0].obtenerX() == c1[2].obtenerX())&&(c1[1].obtenerX()==c1[3].obtenerX())&&(c1[0].obtenerY()==c1[1].obtenerY())&& c1[2].obtenerY()==c1[3].obtenerY())
return 1;
else
    return 0;
}
/*Coordenada c1[4] Rectangulo::obtenerCoordenas()
{
    return c1;
}*/
void Rectangulo::estLargo(int lar)
{
    largo=lar;
}
void Rectangulo::estAncho(int an)
{
    ancho=an;
}
int Rectangulo::obtenerValor()
{
    return x;
}
int Rectangulo::obtenerAncho()
{
    int y1,y2;
    y1=c1[0].obtenerY();
    y2=c1[2].obtenerY();
    ancho=abs(y2-y1);
    return ancho;
}
int Rectangulo::obtenerLargo()
{
    int x1,x2;
    x1=c1[0].obtenerX();
    x2=c1[1].obtenerX();
    largo=abs(x2-x1);
    return largo;
}
int Rectangulo::area()
{
    return largo*ancho;
}
int Rectangulo::perimetro()
{
    return 2*(largo+ancho);
}

int main()
{   int valor;
    Coordenada c1[4];
    Rectangulo R1(c1);
    valor=R1.obtenerValor();
    if(valor==1)
    {
      cout<<"\nLas Coordenadas forman un rectangulo\n\n";
      cout<<setw(15)<<"Ancho: "<<R1.obtenerAncho()<<endl;
      cout<<setw(15)<<"Largo: "<<R1.obtenerLargo()<<endl;
      cout<<setw(15)<<"Area: "<<R1.area()<<endl;
      cout<<setw(15)<<"Perimetro: "<<R1.perimetro()<<endl;
    }
    else
        cout<<"\n\nLas coordenadas no forman un rectangulo\n";
    return 0;
}

Ejercicio 4 entrada de datos por teclado en Clases y Constructores

Codificación CodeBlocks

#include <iostream>
#include <iomanip>
using namespace std;
class Complejo
{
private:
    double parteReal;
    double parteImaginaria;
public:
  Complejo(double =1 , double =1);
  void estComplejo(double, double);
  double obtenerParteReal();
  double obtenerParteImaginaria();
  Complejo obtenerNumeroComplejo();
  Complejo sumaComplejos(Complejo,Complejo);
  Complejo restaComplejos(Complejo,Complejo);
  void imprimeComplejo(Complejo);
};
Complejo::Complejo(double real, double imag)
{
    parteReal=real;
    parteImaginaria=imag;
}
void Complejo::estComplejo(double re, double ima)
{
    parteReal=re;
    parteImaginaria=ima;
}
double Complejo::obtenerParteReal()
{
    return parteReal;
}
double Complejo::obtenerParteImaginaria()
{
    return parteImaginaria;
}
Complejo obtenerNumeroComplejo(Complejo numC)
{
    return numC;
}
Complejo Complejo::sumaComplejos(Complejo c1,Complejo c2)
{
    Complejo resul;
    double pR1,pR2,pI1,pI2,sR,sI;
    pR1=c1.obtenerParteReal();
    pR2=c2.obtenerParteReal();
    pI1=c1.obtenerParteImaginaria();
    pI2=c2.obtenerParteImaginaria();
    sR=pR1+pR2;
    sI=pI1+pI2;
    resul.estComplejo(sR,sI);
    return resul;
}
Complejo Complejo::restaComplejos(Complejo c1,Complejo c2)
{
    Complejo resul;
    double pR1,pR2,pI1,pI2,rR,rI;
    pR1=c1.obtenerParteReal();
    pR2=c2.obtenerParteReal();
    pI1=c1.obtenerParteImaginaria();
    pI2=c2.obtenerParteImaginaria();
    rR=pR1-pR2;
    rI=pI1-pI2;
    resul.estComplejo(rR,rI);
    return resul;
}
void Complejo::imprimeComplejo(Complejo re)
{
    cout<<re.obtenerParteReal()<<" + "<<re.obtenerParteImaginaria()<<"i"<<endl;
}

int main()
{
    double parteR1,parteR2,parteI1,parteI2;
    Complejo  numC1,numC2,resC;
    cout<<"Introduce la parte real del numero complejo 1 : ? ";
    cin>>parteR1;
    cout<<"Introduza la parte imaginaria del numero complejo 1 : ? ";
    cin>>parteI1;
    numC1.estComplejo(parteR1,parteI1);
    cout<<"Introduce la parte real del numero complejo 2 : ? ";
    cin>>parteR2;
    cout<<"Introduza la parte imaginaria del numero complejo 2 : ? ";
    cin>>parteI2;
    numC2.estComplejo(parteR2,parteI2);
    resC=resC.sumaComplejos(numC1,numC2);
    cout<<"El resultado de la suma de los numeros complejos\n";
    cout<<setw(8)<<numC1.obtenerParteReal()<<" + "<<numC1.obtenerParteImaginaria()<<"i"<<endl;
    cout<<setw(8)<<numC2.obtenerParteReal()<<" + "<<numC2.obtenerParteImaginaria()<<"i"<<endl;
    cout<<setw(4)<<"=";
    resC.imprimeComplejo(resC);
    resC=resC.restaComplejos(numC1,numC2);
    cout<<"\n\nEl resultado de la resta de los numeros complejos\n";
    cout<<setw(5)<<numC1.obtenerParteReal()<<" + "<<numC1.obtenerParteImaginaria()<<"i"<<endl;
    cout<<setw(5)<<numC2.obtenerParteReal()<<" + "<<numC2.obtenerParteImaginaria()<<"i"<<endl;
    cout<<setw(4)<<"=";
    resC.imprimeComplejo(resC);
    return 0;
}

Ejercicio 4 Clases y Constructores

Cree una clase llamada complejo para realizar aritmética con numeros complejos. Escriba un programa controlador para probar sus clases.
Los numeros complejos tienen la forma:
parteReal + parteImaginaria * i  donde i es   raiz cuadrada de -1 (sqrt(-1))
Utilice variables double para representar datos de tipo private de una clase. Proporcione funciones miembro de tipo public para cada uno de los siguientes:
a)Suma de dos numeros complejos: las parte real se suman juntas y la parte imaginarias se suman juntas.
b)Resta de dos numeros complejos: la parte real del operando derecho se resta de la parte real del operando izquierdo, y la parte imaginaria del operando derecho se resta de la parte imaginaria del operando izquierdo.
c)Impresión de numerous complejos de la forma (a,b), en donde a es la parte real y b es la parte imaginaria.
Problema propuesto del libro C/C++ y Java Como Programar Cuarta Edición Deitel-Deitel  ejercicio 16.5 pagina 565.

Codificacion CodeBlocks

#include <iostream>
#include <iomanip>
using namespace std;
class Complejo
{
private:
    double parteReal;
    double parteImaginaria;
public:
  Complejo(double =1 , double =1);
  void estComplejo(double, double);
  double obtenerParteReal();
  double obtenerParteImaginaria();
  Complejo obtenerNumeroComplejo();
  Complejo sumaComplejos(Complejo,Complejo);
  Complejo restaComplejos(Complejo,Complejo);
  void imprimeComplejo(Complejo);
};
Complejo::Complejo(double real, double imag)
{
    parteReal=real;
    parteImaginaria=imag;
}
void Complejo::estComplejo(double re, double ima)
{
    parteReal=re;
    parteImaginaria=ima;
}
double Complejo::obtenerParteReal()
{
    return parteReal;
}
double Complejo::obtenerParteImaginaria()
{
    return parteImaginaria;
}
Complejo obtenerNumeroComplejo(Complejo numC)
{
    return numC;
}
Complejo Complejo::sumaComplejos(Complejo c1,Complejo c2)
{
    Complejo resul;
    double pR1,pR2,pI1,pI2,sR,sI;
    pR1=c1.obtenerParteReal();
    pR2=c2.obtenerParteReal();
    pI1=c1.obtenerParteImaginaria();
    pI2=c2.obtenerParteImaginaria();
    sR=pR1+pR2;
    sI=pI1+pI2;
    resul.estComplejo(sR,sI);
    return resul;
}
Complejo Complejo::restaComplejos(Complejo c1,Complejo c2)
{
    Complejo resul;
    double pR1,pR2,pI1,pI2,rR,rI;
    pR1=c1.obtenerParteReal();
    pR2=c2.obtenerParteReal();
    pI1=c1.obtenerParteImaginaria();
    pI2=c2.obtenerParteImaginaria();
    rR=pR1-pR2;
    rI=pI1-pI2;
    resul.estComplejo(rR,rI);
    return resul;
}
void Complejo::imprimeComplejo(Complejo re)
{
    cout<<re.obtenerParteReal()<<" + "<<re.obtenerParteImaginaria()<<"i"<<endl;
}

int main()
{
    Complejo  numC1(8,2),numC2,resC;
    resC=resC.sumaComplejos(numC1,numC2);
    cout<<"El resultado de la suma de los numeros complejos\n";
    cout<<setw(5)<<numC1.obtenerParteReal()<<" + "<<numC1.obtenerParteImaginaria()<<"i"<<endl;
    cout<<setw(5)<<numC2.obtenerParteReal()<<" + "<<numC2.obtenerParteImaginaria()<<"i"<<endl;
    cout<<setw(4)<<"=";
    resC.imprimeComplejo(resC);
    resC=resC.restaComplejos(numC1,numC2);
    cout<<"\n\nEl resultado de la resta de los numeros complejos\n";
    cout<<setw(5)<<numC1.obtenerParteReal()<<" + "<<numC1.obtenerParteImaginaria()<<"i"<<endl;
    cout<<setw(5)<<numC2.obtenerParteReal()<<" + "<<numC2.obtenerParteImaginaria()<<"i"<<endl;
    cout<<setw(4)<<"=";
    resC.imprimeComplejo(resC);

    return 0;
}

Asignación mediante la copia predeterminada de miembros

El operador de asignación (=) se puede utilizar para asignar de manera predeterminada mediante la copia de sus miembros.

Codificación CodeBlocks

#include <iostream>
using namespace std;
class Operaciones
{
private:
    double op1;
    double op2;
public:
    Operaciones(double =1.0, double =1.0);
    ~Operaciones();
    double suma();
    double mult();
};
Operaciones::Operaciones(double d1, double d2)
{
    op1=d1;
    op2=d2;
}
Operaciones::~Operaciones()
{
    cout<<"destruye objeto\n\n";
}
double Operaciones::suma()
{
    return op1+op2;
}
double Operaciones::mult()
{
    return op1*op2;
}
int main()
{
    Operaciones operar1(10.0,20.0),operar2,operar3;
    cout<<"\n\nObjeto uno\n";
    cout<<"\n\nLa suma del objeto uno es "<<operar1.suma()<<endl;
    cout<<"\n\nLa multiplicacion del objeto uno es "<<operar1.mult()<<endl;
    cout<<"\n\n\nObjeto 2\n";
    cout<<"\n\nLa suma del objeto uno es "<<operar2.suma()<<endl;
    cout<<"\n\nLa multiplicacion del objeto uno es "<<operar2.mult()<<endl;
    operar3=operar1;
    cout<<"\n\n\nObjeto tres\n";
    cout<<"\n\nLa suma del objeto uno es "<<operar3.suma()<<endl;
    cout<<"\n\nLa multiplicacion del objeto uno es "<<operar3.mult()<<endl;

return 0;
}

Asignación en el manejo de objetos

El operador de asignación (=) se utiliza para asignar un objeto a otro objeto del mismo tipo. La asignacion se lleva mediante la copia de miembros; cada miembro del objeto a la derecha del operador de asignación se asigna de  forma individual al mismo miembro en otro objeto.

Codificación en CodeBlocks

#include <iostream>
using namespace std;
class Ejemplo
{
private:
    int valor;
public:
    Ejemplo();
    ~ Ejemplo();
    void asignarValor(int);
    int obtenerValor();
};
void Ejemplo:: asignarValor(int x)
{
    valor=x;
}
int Ejemplo:: obtenerValor()
{
    return valor;
}
Ejemplo::Ejemplo()
{
    cout<<"\n\nSe construye el objeto\n\n";
    valor=0;
}
Ejemplo::~Ejemplo()
{
    cout<<"\n\nSe destruye el valor "<<valor<<"  en el objeto\n\n";
}
int main()
{
    Ejemplo  e1,e2;
    int numero;
    cout<<"El valor es "<<e1.obtenerValor()<<endl;
    cout<<"\n\nIntroduce un valor: ? ";
    cin>>numero;
    e1.asignarValor(numero);
    cout<<"El valor del objeto uno es "<<e1.obtenerValor()<<endl;
    e2=e1;
    cout<<"El valor del objeto dos es "<<e2.obtenerValor()<<endl;
    return 0;
}

Destructores

El destructor es una funcion miembro especial de una clase que sirve  para destruir el objeto.
Se distingue porque tiene el character ~ (tilde) seguido del  nombre de la clase. El destructor es el complemento del constructor.
Los destructores son llamados de forma automatico, cuando  un objeto deja de existir.


Codificación CodeBlocks
#include <iostream>
using namespace std;
class Ejemplo
{
private:
    int valor;
public:
    Ejemplo();
    ~ Ejemplo();
    void asignarValor(int);
    int obtenerValor();
};
void Ejemplo:: asignarValor(int x)
{
    valor=x;
}
int Ejemplo:: obtenerValor()
{
    return valor;
}
Ejemplo::Ejemplo()
{
    cout<<"\n\nSe construye el objeto\n\n";
    valor=0;
}
Ejemplo::~Ejemplo()
{
    cout<<"\n\nSe destruye el valor "<<valor<<"  en el objeto\n\n";
}
int main()
{
    Ejemplo  e1;
    int numero;
    cout<<"El valor es "<<e1.obtenerValor()<<endl;
    cout<<"\n\nIntroduce un valor: ? ";
    cin>>numero;
    e1.asignarValor(numero);
    cout<<"El valor es "<<e1.obtenerValor()<<endl;
    return 0;
}

Ejercicio 3 modificado Clases y Constructores

Modifique el programa escrito para el ejercicio b para incluir un menu que ofrezca al usuario las siguientes opciones:
1.-Agregar un empleado
2.-Modificar los datos del empleado
3.-Eliminar a un empleado
4.Salir del Menu
En respuesta a una opción el programa deberá iniciar la acción apropiada para implementar la opción.
Problema propuesto del libro C++ para ingeniería y ciencias Gary J. Bronson ejercicio 9.3 problema 8.c pag. 533.


Codificación CodeBlocks


#include <iostream>
#include <iomanip>
using namespace std;
class Empleado
{
private:
    int idEmpleado;
    double tasaSalarial;
    int horasTrabajadas;
public:
    Empleado(int,double,int);
    Empleado();
    void estDatosEmpleado(int, double,int);
    void estId(int);
    void estTasaSal(double);
    void estHorasTrab(int);
    int obtenerId();
    double obtenerTasaSal();
    int obtenerHorasTrab();
    void mostrarDatosEmpleado();
    void mdificarDatosEmp();
};
Empleado::Empleado(int id,double tSalarial,int horas)
{
    idEmpleado=id;
    tasaSalarial=tSalarial;
    horasTrabajadas=horas;
}
Empleado::Empleado()
{
    idEmpleado=0;
    tasaSalarial=0;
    horasTrabajadas=0;
}
void Empleado::estDatosEmpleado(int id, double tSalarial,int horas)
{
    idEmpleado=id;
    tasaSalarial=tSalarial;
    horasTrabajadas=horas;
}
void Empleado::estId(int id)
{
 idEmpleado=id;
}
void Empleado::estTasaSal(double tSalarial)
{
     tasaSalarial=tSalarial;
}
void Empleado::estHorasTrab(int horas)
{
    horasTrabajadas=horas;
}
int Empleado::obtenerId()
{
    return idEmpleado;
}
double Empleado::obtenerTasaSal()
{
    return tasaSalarial;
}
int Empleado::obtenerHorasTrab()
{
    return horasTrabajadas;
}
void Empleado::mostrarDatosEmpleado()
{
     cout<<setw(25)<<" Id Empleado: "<<idEmpleado<<endl;
     cout<<setw(25)<<"Tasa Salarial: "<<tasaSalarial<<endl;
     cout<<setw(25)<<"Horas Trabajadas : "<<horasTrabajadas<<endl;
}
Empleado modificarDatosEmp(Empleado emp)
{
    int opc,id,horas;
    double ts;
    cout<<"1)id\n2)Tasa Salarial\n3)Horas Trabajadas\n4)Todos los datos";
    cout<<"Seleccione opcion: ";
    cin>>opc;
    switch(opc)
    {
    case 1: cout<<"introduce el nuevo ID de empleado: ? ";
            cin>>id;
            emp.estId(id);
            break;
    case 2: cout<<"Introduce la nueva Tasa Salarial : ? ";
            cin>>ts;
            emp.estTasaSal(ts);
            break;
    case 3:cout<<"Introduce las horas trabajadas: ? ";
           cin>>horas;
           emp.estHorasTrab(horas);
           break;
    case 4: cout<<"introduce los datos del empleado\n\n";
                    cout<<"Nuevo Id Empleado: ? ";
                    cin>>id;
                    cout<<"Nuevo Tasa Salarial : ? ";
                    cin>>ts;
                    cout<<"Nuevo Horas Trabajadas : ? ";
                    cin>>horas;
                    emp.estDatosEmpleado(id,ts,horas);
                    break;

    }
    return  emp;
}
int menu()
{
    int opc;
cout<<"\n\n1.-Agregar un empleado\n\n";
cout<<"\n\n2.-Modificar los datos del empleado\n\n";
cout<<"\n\n3.-Eliminar a un empleado\n\n";
cout<<"\n\n4.Salir del Menu\n\n";
cout<<"Seleccione la opcion: ";
cin>>opc;
return opc;
}
int buscarIdEmpleado(Empleado e[10],int Id,int n)
{
    int i=0,x=-1,bandera=0;
    while(i<n && bandera==0)
    {
        if(e[i].obtenerId()==Id)
        {
         bandera=1;
         x=i;
        }
        else
            i++;
    }
    return x;
}
int main()
{
    int id,horas,i=-1,opcion,ne=0,p;
    char sigue;
    double tasa;
    Empleado e1[10],e;
    do
    {
      opcion=menu();
      switch(opcion)
      {
          case 1:
                i++;
                cout<<"\n\nIntroduce Datos Empleado \n\n";
                cout<<"\nIdentificacion Empleado  : ? ";
                cin>>id;
                cout<<"Tasa Salarial: ? ";
                cin>>tasa;
                cout<<"Horas Trabajadas: ? ";
                cin>>horas;
                e1[i].estDatosEmpleado(id,tasa,horas);
                ne++;
                break;
          case 2: cout<<"\n\nmodificacion de datos empleado\n\n";
                  cout<<"Introduzca id empleado : ? ";
                   cin>>id;
                    p=buscarIdEmpleado(e1,id,ne);
                   if(p!=-1)
                   {
                    e1[p].mostrarDatosEmpleado();
                    e1[p]=modificarDatosEmp(e1[p]);
                    cout<<"\n\nNuevo datos del empleado\n\n";
                    e1[p].mostrarDatosEmpleado();
                   }
                   else
                    cout<<"\n\nNo existe id empleado\n\n";
                    break;
          case 3:
               cout<<"\n\nEliminando un empleado\n\n";
               cout<<"Introduce el ID empleado a eliminar : ? ";
               cin>>id;
               p=buscarIdEmpleado(e1,id,ne);
               if(p!=-1)
                   {
                   e1[p].mostrarDatosEmpleado();
                   cout<<"Estas seguro que lo quieres eliminar (s/n): ? ";
                   cin>>sigue;
                   if(sigue=='s' || sigue=='S')
                   {
                   e1[p].estId(0);
                   e1[p].estTasaSal(0);
                   e1[p].estHorasTrab(0);
                    cout<<"\n\nDatos empleado Eliminado\n\n";
                   e1[p].mostrarDatosEmpleado();
                   }
                   }
                else
                    cout<<"No existe "<<id <<" de empleado "<<endl;
                break;
        case 4 : cout<<"\n\nSalida Programa\n\n";
                  break;
      }
    }
   while(opcion !=4);
    return 0;
}

Ejercicio 3 Clases y constructores

a)Construya una definición de clase que pueda usarse para representar a un empleado de una compañia. Cada empleado es definido por un número entero de identificación, una tasa salarial en punto flotante y el número máximo de horas que el empleado debería trabajar cada semana. Los servicios de la clase deberán proporcionar la capacidad para introducir datos, cambiar y desplegar los datos existentes para un nuevo empleado.
Incluya la definición de clase creada para el ejercicio a en un programa en C++ functional que le pida al usuario que introduzca datos para tres empleado y despliegue los datos introducidos.
Problema propuesto en el libro C++ para ingenieria y ciencias Gary J. Bronson Ejercicio 9.3 problema 8 pagina 533.

Codificación CodeBlocks

#include <iostream>
#include <iomanip>
using namespace std;
class Empleado
{
private:
    int idEmpleado;
    double tasaSalarial;
    int horasTrabajadas;
public:
    Empleado(int,double,int);
    Empleado();
    void estDatosEmpleado(int, double,int);
    void estId(int);
    void estTasaSal(double);
    void estHorasTrab(int);
    int obtenerId();
    double obtenerTasaSal();
    int obtenerHorasTrab();
    void mostrarDatosEmpleado();
};
Empleado::Empleado(int id,double tSalarial,int horas)
{
    idEmpleado=id;
    tasaSalarial=tSalarial;
    horasTrabajadas=horas;
}
Empleado::Empleado()
{
    idEmpleado=0;
    tasaSalarial=0;
    horasTrabajadas=0;
}
void Empleado::estDatosEmpleado(int id, double tSalarial,int horas)
{
    idEmpleado=id;
    tasaSalarial=tSalarial;
    horasTrabajadas=horas;
}
void Empleado::estId(int id)
{
 idEmpleado=id;
}
void Empleado::estTasaSal(double tSalarial)
{
     tasaSalarial=tSalarial;
}
void Empleado::estHorasTrab(int horas)
{
    horasTrabajadas=horas;
}
int Empleado::obtenerId()
{
    return idEmpleado;
}
double Empleado::obtenerTasaSal()
{
    return tasaSalarial;
}
int Empleado::obtenerHorasTrab()
{
    return horasTrabajadas;
}
void Empleado::mostrarDatosEmpleado()
{
     cout<<setw(25)<<" Id Empleado: "<<idEmpleado<<endl;
     cout<<setw(25)<<"Tasa Salarial: "<<tasaSalarial<<endl;
     cout<<setw(25)<<"Horas Trabajadas : "<<horasTrabajadas<<endl;
}

int main()
{
    int id,horas;
    double tasa;
    Empleado e1,e2(1031,22.50,30),e3;  //datos del empleado 2 inicializados
    cout<<"\n\nIntroduce Datos Empleado 1\n\n";
    cout<<"\nIdentificacion Empleado 1 : ? ";
    cin>>id;
    e1.estId(id);
    cout<<"Tasa Salarial: ? ";
    cin>>tasa;
    e1.estTasaSal(tasa);
    cout<<"Horas Trabajadas: ? ";
    cin>>horas;
    e1.estHorasTrab(horas);
    cout<<"\n\nIdentificacion Empleado 3 : ? ";
    cin>>id;
    cout<<"Tasa Salarial: ? ";
    cin>>tasa;
    cout<<"Horas Trabajadas: ? ";
    cin>>horas;
    e3.estDatosEmpleado(id,tasa,horas);
    cout<<"\n\nDatos Empleados 1"<<endl;
    e1.mostrarDatosEmpleado();
    cout<<"\n\nDatos Empleado 2 "<<endl;
    e2.mostrarDatosEmpleado();
    cout<<"\n\nDatos Empleado 3 "<<endl;
    e3.mostrarDatosEmpleado();

    return 0;
}

Ejercicio 2 clases y constructores

Construya una clase llamada Luz que simule un semáforo. El atributo de color de la clase deberá cambiar verde a Amarillo a Rojo y luego de vuelta a verde  por la function cambio( ) de la clase. Cuando sea crea un objeto Luz Nuevo su color inicial deberá ser  rojo.
Ejercicio propuesto por el libro C++ para ingenieria y ciencias Gary J. Bronson ejercicios 9.3 problema 7 pagina 532.

Codificación CodeBlocks

#include <iostream>
using namespace std;
class Luz
{
private:
    string color;
public:
    Luz();
void cambio();
};
Luz::Luz()
{
    color="ROJO";
}
void Luz::cambio()
{ int i;
    while(1)
    {
    cout<<color<<endl<<endl;
    color="VERDE";
    cout<<color<<endl<<endl;
    color="AMARILLO";
    cout<<color<<endl<<endl;
    color="ROJO";
    }
}
int main()
{Luz  l1;
l1.cambio();
    return 0;
}

Constructor(es) en una clase

Un constructor en una clase es una función que tiene el mismo nombre de la clase. Pueden existir varios constructores cada uno con  tipos de parametros  diferentes  y sirven para inicializar los datos miembro de la clase, cuando se crea un objeto.
El constructor puede realizar otras tareas cuando  es llamada. Otra punto importante no debe entregar un tipo de dato y tampoco tener la palabra reservada void.
Si no se implementa un constructor en la clase, el compilador sumistra  uno, que inicializa en cero los valores.



Ejemplo  :

class Cuadrado
{
    private:
     double lado;
public:
Cuadrado(double );  // constructor
Cuadrado( );   //constructor
void asignarLado(double);
double obtenerLado( );
double areaC( );
double perimetroC( );
void  mostrarDatos( );
};
Cuadrado::Cuadrado(double a) //constructor
{
   lado=a;
}
Cuadrado::Cuadrado()  // constructor
{
    lado=0;
}
void Cuadrado:: asignarLado(double a)
{
      lado=a;
}
double Cuadrado::obtenerLado( )
{
return lado;
}
double Cuadrado::areaC( )
{
    return lado*lado;
}
double Cuadrado::perimetroC( )
{
   return 4*lado;
}
void Cuadrado:: mostrarDatos( )
{
  cout<<"\n\nDatos de un cuadrado\n\n";
  cout<<"Lado = "<<lado<<endl;
 cout<<"Area = "<<area( )<<endl;
cout<<"Perimetro = "<<perimetro( )<<endl;
}

Ejemplo 1 clase Rectangulo

Diseñe una clase llamada Rectangulo que tenga como datos miembro en doble precision largo y ancho. y las funciones miembro  de asignarDatos,asignarAncho, asignarLargo, area, perimetro,
 mostrarDatos, obtenerAncho y obtenerLargo.

Codificación  CodeBlocks

#include <iostream>
using namespace std;
class Rectangulo
{
private:
    double largo;
    double ancho;
public:
    Rectangulo(double, double);
    Rectangulo();
    void asignarDatos(double, double);
    void asignarAncho(double);
    void asignarLargo(double);
    double area();
    double perimetro();
    void mostrarDatos();
    double obtenerAncho();
    double obtenerLargo();

};
Rectangulo::Rectangulo(double a, double b)
{
    ancho=a;
    largo=b;
}
Rectangulo::Rectangulo()
{
    ancho=0;
    largo=0;
}
void Rectangulo::asignarDatos(double a, double b)
{
    ancho=a;
    largo=b;
}
void Rectangulo::asignarAncho(double a)
{
    ancho=a;
}
void Rectangulo::asignarLargo(double b)
{
    largo=b;
}
double Rectangulo::obtenerAncho()
{
    return ancho;
}
double Rectangulo::obtenerLargo()
{
    return largo;
}
double Rectangulo::area()
{
    return ancho*largo;
}
double Rectangulo::perimetro()
{
    return 2*(ancho+largo);
}
void Rectangulo::mostrarDatos()
{
    cout<<"Datos del Rectangulo\n\n";
    cout<<"Ancho = "<<ancho<<endl;
    cout<<"Largo = "<<largo<<endl;
    cout<<"Area = "<<area()<<endl;
    cout<<"Perimetro = "<<perimetro()<<endl;
}
int main()
{
    Rectangulo r1(25,45),r2;
    double a1,l1;
    cout<<"Rectangulo con datos inicializados\n\n";
    r1.mostrarDatos();
    cout<<"\n\n datos del rectangulo introducidos por teclado\n\n";
    cout<<"\n\nIntroduce valor ancho de un rectangulo : ? ";
    cin>>a1;
    cout<<"\nintroduce valor largo de un rectangulo : ? ";
    cin>>l1;
    r2.asignarAncho(a1);
    r2.asignarLargo(l1);
    r2.mostrarDatos();
    return 0;
}

Formato para declarar una clase en C++

El formato para declarar una clase en C++ es:

class nombreClase
{
private:
    lista_datos_miembro;     // son  las variables donde defines el tipo de dato nombre variable y ;
public:
  lista_de_funciones_miembro // pueden ser los prototipos o implementación de la función
};

Si se define solo los prototipos de las funciones
enseguida debe existir una seccion de implementación


ejemplo:

class Fecha
{
private:
int dia;
int mes;
int anio;

public:
Fecha(int,int,int); //esta es una function miembro especial llamada constructor que sirve para
Fecha();               //iniciar datos del objeto tiene el mismo nombre de la clase
void establecerFecha(int,int,int);
void mostrarFecha();
void establecerDia(int);
void establecerMes(int);
void establecerAnio(int );
int obtenerDia();
int obtenerMes();
int obtenerAnio();
};
Fecha::Fecha(int d, int m, int a)
{
   dia=d;
   mes=m;
   anio=a;
}
Fecha::Fecha()
{
cout<<"Introduce dia: ? ";
cin>>dia;
cout<<"Introduce con valor numerico mes: (1) enero 2)febrero... 12)diciembre : ? ";
cin>>mes;
cout<<"introduce anio: ? ";
cin>>anio;
}
 void Fecha::establecerFecha(int d, int m, int a)
{
dia=d;
mes=m;
anio=a;
}
void Fecha::establecerDia(int d)
{
dia=d;
}
void Fecha::establecerMes(int m)
{
mes=m;
}
void Fecha::establecerAnio(int a)
{
anio=a;
}
int Fecha::obtenerDia()
{
return dia;
}
int Fecha::obtenerMes()
{
return mes;
}
int Fecha::obtenerAnio()
{
return anio;
}
void Fecha::mostrarFecha()
{
cout<<setfill('0')<<setw(2)<<dia<<" / "<<setw(2)<<mes<<" / "<<setw(4)<<anio<<endl;

Introduccion a la programacion orientada a objetos

La programacion orientada a objetos (POO) se basa en el  modelado de objetos fisicos o abstractos que aparecen en el dominio del problema.
La parte fundamental de la programacion orientada a objetos es encapsular en una sola unidad los datos y las funciones que manipulan los datos. A estos datos se les llama datos miembro y funciones miembro (en C++) que definen las caracteristicas del objeto y su comportamiento.
Cuando se define una clase la palabra reservada que se utiliza es class en C++.

class nombreClase
{
  lista_de_datos_miembro
  lista_de_funciones_miembro
};

Los objetos se crean a partir de la definicion de la clase.
Las funciones miembro sirven para accesar  a los datos directamente. Recuerde los datos estan encapsulados en una sola unidad. La modificación de los datos de un objeto es por medio de las funciones miembro.

En una aplicación  donde el lenguaje de programacion es orientado a objetos, el programa se organiza por un conjunto de objetos que contienen datos y funciones miembro que se  comunican entre si mediante las funciones miembro (es decir, se envian mensajes).

Las etapas que se requieren para modelar una aplicacion utilizando el paradigma orientado a objetos
son:

1)Identificar los objetos del problema
2)Agrupar en clases los objetos con caracteristicas y comportamiento similares.
3)Definir los datos y funciones miembro de cada una de las clases.
4)Identificar las relaciones que existen entre las diferentes clases

Nota:
En algunos lenguajes  a las funciones miembro se les llama métodos y a los datos miembro atributos.

Una clase describe un objeto, pero es un nuevo tipo de dato y apartir de esa clase se definen variables o instancia.

Ejemplo la clase persona
datos miembro: nombre, domicilio, rfc, telefono1, telefono2, correo_electronico
                                                                    
Funciones miembro  establecerDatos( ),mostrarDatos( )

las definir la clase podemos decir que

alumno, empleado, maestro, cliente  son objetos de tipo persona