Introduccion a C++.

1. Clases.

Una clase contiene atributos y metodos.

Existen metodos especiales denominados constructores y destructores.

Un atributo puede ser de tipo escalar o no escalar.

La siguiente declaracion muestra el uso del concepto de clase.

/*** 
Clase1.h

Uso de una clase con atributos escalares, se declaran atributos y
metodos como publicos.

**/

#include <iostream>

class Clase1 {
public:
 int i;
 long l;
 char ch;
 float f;
 double d;
 bool b;
 void *p;


 Clase1() {
   cout << "Invocando constructor"<<'\n';
   i= 10;
   l= 123456789;
   ch= 'a';
   f=3.14159;
   d=2.99E99;
   b = 1==1;
   p = this;
 }
 ~Clase1() {
   cout << "Invocando destructor"<<'\n';
 }
 void imprimir() {
   cout << i <<'\n';
   cout << l <<'\n';
   cout << ch <<'\n';
   cout << f <<'\n';
   cout << d <<'\n';
   cout << b <<'\n';
   cout << p <<'\n';
 }

};
//Clase1

Para poder utilizar esta clase en otro programa, se debe incluir el archivo Clase1.h y declarar
una variable de tipo Clase1.
Cuando se declara una variable de tipo Clase1, se invoca su constructor, que es la funcion que
se encarga de iniciarlizar los valores de los atributos.
Teniendo una variable de tipo clase, se puede usar todo atributo o metodo publico.
Cuando concluye el tiempo de vida de la variable, se invoca al constructor

2. Archivos de cabecera e implantacion

En C++ es usual declar una clase en un archivo ".h" pero sin codificar los metodos y en un 
archivo ".cpp" o ".C" se implantan los metodos.

El siguiente ejemplo muestra una Clase2 que tiene un arreglo de objetos de tipo Clase1. En
el archivo Clase2.h se declara lo siguiente:


/** Clase2
 Clase que contiene un arreglo de objetos de Clase1
**/
#define SZ 5

#include "Clase1.h"

class Clase2 {
 public:
  Clase1 arr[SZ]; //cuando se crea un objeto de tipo Clase2, se crean SZ objetos
  void imprimir() ; //se declara la funcion
};
//Clase2


Y en otro archivo, Clase2.cpp, se define la funcion imprimir

/**  Clase2
 define el codigo de los metodos
**/
#include "Clase2.h"

void Clase2::imprimir() {
         for (int i=0;i<SZ;i++) {
            cout << i <<" ";
            arr[i].imprimir();
         }
}
//Clase2.cpp

Y el programa cliente que utiliza a la clase es:
#include "Clase2.h"

main() {
   Clase2 cl;
   cl.imprimir();
}

Para compilar y enlazar esta serie de programas

g++ -o MainClase2 MainClase2.cpp Clase2.cpp

3. Constructores

Los constructores pueden definirse con parametros y pueden declararse varios.

El archivo Fecha.h que declara la clase

/** Fecha
Muestra el uso de constructores con distintos parametros y parametros por
omision
**/

class Fecha {
  private:
    int d,m,a;
  public:
     Fecha();
     Fecha(int yyyy,int mm=1,int dd=1); //parametros por omision
     void imprimir();
};
//Fecha

El que la implanta es Fecha.cpp


/** Fecha
Implantacion del uso de constructores con distintos parametros y parametros por
omision
**/

#include "Fecha.h"
#include <iostream>

Fecha::Fecha(): d(0),m(0),a(0) { }
Fecha::Fecha(int yyyy,int mm,int dd): d(dd),m(mm),a(yyyy) { }
void Fecha::imprimir() {
   cout << "Y= "<<a<<" M= "<<m<<" D= "<<d<<'\n';
}
//Fecha.cpp


Y el que usa la clase es:
//MainFecha.cpp
#include "Fecha.h"

main() {
 Fecha f1,f2(2001),f3(2001,3),f4(2001,9,24);
 f1.imprimir();
 f2.imprimir();
 f3.imprimir();
 f4.imprimir();
}


Un parametro por omision es aquel que toma el valor indicado en su declaracion en caso de 
que no sea provisto. 

Para generar el ejecutable
g++ -o MainFecha MainFecha.cpp Fecha.cpp


4. Control de acceso.

El encapsulamiento es una tecnica basica en cualquier lenguaje de objetos.
En C++ existen 3 tipos de encapsulamiento, public, private y protected.
Cuando un metodo o atributo es private, solo se puede accesar desde los metodos de la clase
Un metodo o atributo public puede ser accesado desde cualquier localizacion de codigo
Es recomendable ocultar todos los atributos y otorgar funciones de acceso y cambio de los atributos.
Cuando un metodo se declara privado, no puede ser invocado desde fuera de la clase que lo declara
/** Contador
 Clase que muestra el uso de encapsulamiento
**/

class Contador {
 private:
     int valor;
     bool validar() {
        return valor < 0;
    }
 public:
    Contador();
    Contador(int v);
    int getValor();
    void setValor(int v);
    void inc();
    void dec();
};
//Contador

//Contador.cpp
#include "Contador.h"
#include <iostream>

Contador::Contador():valor(0){ };
Contador::Contador(int v) {
   valor = v;
   if (!validar() ) {
     cout << "Error al asignar valor  \n";
   }
}
int Contador::getValor() { return valor;}
void Contador::setValor(int v) {
   valor = v;
   if (!validar() ) {
     cout << "Error al asignar valor  \n";
   }
}
void Contador::inc() {
   valor++;
}
void Contador::dec() {
   valor--;
   if (!validar() ) {
     cout << "Error al asignar valor  \n";
   }
}

//MainContador.cpp
#include "Contador.h"
#include <iostream>

main() {
  Contador c(2);
  for(int i=5;i>0;i--) {
      c.dec();
//      c.validar(); //esto no compila
      cout<<c.getValor()<<'\n';
  }

}


5. Funciones y clases amiga (Friends)

C++ tiene una manera de romper el encapsulamiento.

Una funcion se declara como friend de una clase cuando se quiere que los atributos privados sean
visible por esa funcion
Una clase se declara como friend de otra clase cuando se quiere que los atributos privados sean
visible por esa funcion


/** Prestadora
Clase que declara una funcion y clase friend
**/
#include <iostream>


class Prestadora {
private:
   int x;

public:
  Prestadora():x(0) { }
  friend void famiga(int dx,Prestadora &p);
  friend class ImpresoraPrestadora;
};

class ImpresoraPrestadora{
  public:
    void imprimir(Prestadora pr ) {
       cout<<pr.x<<'\n';
    }
};
//Prestadora

//MainPrestadora.cpp
#include "Prestadora.h"

void famiga(int dx,Prestadora &p) {
    p.x += dx;
}


main() {
  Prestadora pr;
  ImpresoraPrestadora impr;

  famiga(1,pr);
  impr.imprimir(pr);
}


6. Referencias y apuntadores.

Cuando en C++ se pasa un parametro a un metodo, este se pasa por valor (o copia). 
Con un tipo de dato  escalar no existen problemas. Cuando es un tipo de dato clase, se hace una 
copia de byte a byte pero puede resultar costoso.

Otro metodo, impulsado por C, es pasar en el parametro el apuntador al dato. Con esto se lograba
que fuera eficiente el paso por valor, sin embargo la sintaxis resultaba confusa.

Una manera de pasar la direccion del dato pero sin tener que utilizar apuntadores se conoce como
paso por referencia, el cual permite que se use dentro del metodo el objeto de manera 
transparente pero no se aplica una copia.

Cuando es una referencia, se declara como

retorno metodo(Clase & p1, ...)

donde el simbolo & permite indicar que se pasa por referencia el parametro 1.




/**
 Uso de apuntadores y referencias
**/
class Clase3 {
  private:
     char ch;
  public:
     Clase3(char c):ch(c){ }
     void apuntador(Clase3 * ptr) ;
     void referencia(Clase3& ref) ;
    void valor(Clase3 nuevo) ;
    void imprimir();
};
//Clase3


//Clase3.cpp
#include "Clase3.h"
#include <iostream>

 void Clase3::apuntador(Clase3 * ptr) {
       cout << ptr <<'\n';
        ch = ptr->ch;
 }
 void Clase3::referencia(Clase3& ref) {
       cout << &ref <<'\n';
        ch = ref.ch;
 }
 void Clase3::valor(Clase3 nuevo) {
       cout << &nuevo <<'\n';
       ch = nuevo.ch;
 }
 void Clase3::imprimir() {
   cout <<ch<<'\n';
 }

//MainClase3.cpp
#include "Clase3.h"

main() {
  Clase3 cl1('a');
  Clase3 cl2('z');

  cl2.valor(cl1);
  cl2.imprimir();
  cl2.apuntador(&cl1);
  cl2.imprimir();
  cl2.referencia(cl1);
  cl2.imprimir();

}



7. Auto referencia

Cuando un objeto tiene que regresarse a si mismo como resultado de una funcion, se puede utilizar
un apuntador a si mimso denominado this.

La combinacion de la auto referencia this con el concepto de referencias permite escribir este
tipo de casos.

/**
 Uso de auto referencia this
**/
class Ego {
 private:
  int dato;
 public:
   Ego(int d):dato(d){ }
   Ego & modificate(int x);
   int getDato();
   void setDato(int x);
};
//Ego

//Ego.cpp
#include "Ego.h"

Ego& Ego::modificate(int x) {
    this->dato = x*100;

    return *this;
}

int Ego::getDato() {
   return this->dato; //return dato;
}

void Ego::setDato(int x) {
   this->dato = x;
}


//MainEgo.cpp
#include "Ego.h"

#include <iostream>

void imprimir(Ego & tu) {
   cout<<tu.getDato();
}
main() {
 Ego yo(1);
 imprimir(yo.modificate(5));
  
}



8. Sobrecarga de operadores.

Con C++ es posible que se invoquen funciones usando los operadores aritmeticos, relacionales,
conversion y referencia.

Esto se conoce como sobrecarga y consiste en que:

A objeto,a;
objeto=A.suma(a,a);

se hace como
objeto = a +a ;

y se dice que el operado aritmetico + esta sobrecargado, de tal manera que se esta definiendo
la operacion de suma para los objetos de clase A.

/**
 Uso de sobrecarga de operadores
**/
#define SZ 1024
class NuevoTipo {
 private:
   int numero;
   char  cadena[SZ];
 public:
    NuevoTipo();
    NuevoTipo(int x,const char * s);
    NuevoTipo& operator+= (NuevoTipo& op);
    NuevoTipo operator+ (NuevoTipo& op);
    operator int()  { return numero;}
    operator char*()  { return cadena;}
    void imprimir();
};
//NuevoTipo

//NuevoTipo.cpp
#include "NuevoTipo.h"
#include <string.h>
#include <iostream.h>
NuevoTipo::NuevoTipo():numero(0) { strcpy(cadena,""); }
NuevoTipo::NuevoTipo(int x,const char *s): numero(x) { strcpy(cadena,s);}
NuevoTipo& NuevoTipo::operator+= (NuevoTipo &op) {
   numero +=  op.numero;
   strcat(cadena,op.cadena);
   return *this;
}
NuevoTipo NuevoTipo::operator+(NuevoTipo& op1) {
   int n = numero + op1.numero;
   char cad[SZ] = "";
   strcpy(cad,cadena);
   strcat(cad,op1.cadena);
   return NuevoTipo(n,cad);
}
void NuevoTipo::imprimir() {
  cout << numero << " "<<cadena<<'\n';
}

//MainNuevoTipo.cpp
#include "NuevoTipo.h"
#include <iostream.h>

main() {
  NuevoTipo n1(10,"hola");
  NuevoTipo n2(20,"mundo");
  NuevoTipo n3;
  n3 = n1+n2;
  n1.imprimir();
  n2.imprimir();
  n3.imprimir();
  n1 += n2;
  n1.imprimir();
  int i= n1;
  cout << i+1 << '\n';
  char * s= n1;
  cout << s << '\n';
}



9. Herencia Simple.

La herencia simple se presenta cuando una clase toma la definicion de otra clase ya existente.

Se puede hacer herencia de atributos y metodos calificados como public y protected.

Un atributo o metodo calificado como protected permite que la clase descendiente la pueda accesar
pero la proteje de clases externas.



#ifndef __ANCESTRO_H__
#define __ANCESTRO_H__
/**
  Clase Ancestro para ilustrar herencia
**/
class Ancestro {
   private:
      int x;
   protected:
      void imprimir();
   public:
      Ancestro():x(0) {};
      Ancestro(int v):x(v) {};
      int getX() const;
      void setX(const int v);
      operator int() const { return getX(); }
      Ancestro & operator = (int v);
};
//Ancestro
#endif

//Ancestro.cpp
#include "Ancestro.h"
#include <iostream>
int Ancestro::getX() const {
  return x;
}

void Ancestro::setX(const int v) {
  x = v;
}

Ancestro& Ancestro::operator=(int v) {
   setX(v);
   return *this;
}
void Ancestro::imprimir() {
  cout<<x<<'\n';
}

#ifndef __DESCENDIENTE_H__
#define __DESCENDIENTE_H__

/**
 Clase Descendiente
**/
#include "Ancestro.h"

class Descendiente : public Ancestro {
  private:
      char * cadena;
  public:
     Descendiente(char *s);
     Descendiente(int d,char *s) ;
     char * getCadena() const;
     operator char *() const { return cadena;}
     Descendiente & operator = (int v);
     void p();
};
//Descendiente
#endif
//Descendiente.cpp
#include "Descendiente.h"
#include <string.h>

Descendiente::Descendiente(char *s):Ancestro() {
  cadena=s;
}
Descendiente::Descendiente(int d,char *s):Ancestro(d) {
  cadena=s;
}

char * Descendiente::getCadena() const {
   return cadena;
}

Descendiente& Descendiente::operator=(int v) {
  setX(v);
  return *this;
}
void  Descendiente::p(){
   imprimir();
}

//TestHerencia.cpp

#include "Ancestro.h"
#include "Descendiente.h"
#include <iostream>

main() {
  Ancestro papa;
  Descendiente hijo("gollum");
  papa = 2;
  cout << (int) papa << '\n';
  hijo = 10;
  cout << (int) hijo << '\n';
  cout << (char *) hijo << '\n';
}


10. Polimorfismo y ligadura dinamica.

Polimorfismo es la capacidad de un objeto de cambiar de forma con respecto al medio ambiente
(contexto) donde se desenvuelve.

El polimorfismo es implantado en los lenguajes via el concepto de ligadura dinamica.
Cuando un lenguaje tiene ligadura estatica, no es capaz de tomar la funcion a invocar basandose
en el tipo de dato de ejecucion.
C++ por omision implanta ligadura estatica.

#ifndef __A_H__
#define __A_H__

#include <iostream>

class A{
  public:
      void p() {
                cout << "soy A"<<'\n';
      }
};

#endif

#ifndef __B_H__
#define __B_H__
#include "A.h"
#include <iostream>

class B:public A{
  public:
      void p() {
                cout << "soy B"<<'\n';
      }
};

#endif

#include "A.h"
#include "B.h"

void f(A& ref){
  ref.p();
}
main() {
  A a;
  B b;

  a.p();
  b.p();

  f(b);
   
}

El polimorfismo debe presentarse en la funcion f(), donde espera recibir un objeto de tipo A
(en esta caso cualquier objeto de clase A o B tienen el tipo A). Sin embargo el resultado
al ejecutar
soy A
soy B
soy A

es decir, uso el objeto de tipo B como si fuera uno de tipo A; usando la alternativa de ligadura
estatica.


Para cambiar el comportamiento de que un metodo sea manejado con ligadura estatica, y sea
 manipulado con ligadura dinamica, se debe usar la palabra reservada virtual. Al aplicar dicho
prefijo a un metodo se conoce como un metodo virtual.

#ifndef __C_H__
#define __C_H__

#include <iostream>

class C{
  public:
      virtual void p() {
                cout << "soy C"<<'\n';
      }
};

#endif

#ifndef __D_H__
#define __D_H__
#include "C.h"
#include <iostream>

class D:public C{
  public:
      virtual void p() {
                cout << "soy D"<<'\n';
      }
};

#endif

#include "C.h"
#include "D.h"

void g(C& ref){
  ref.p();
}

main() {
  C a;
  D b;

  a.p();
  b.p();

  g(b);
}

En este caso, la funcion g() es donde se hace presente el polimorfismo. Al pasar un objeto de 
tipo D, dinamicamente y en tiempo de ejecucion descubre que debe invocar la funcion D::p() 
gracias a la ligadura dinamica.



11. Clases Abstractas

En cualquier sistema orientado a objetos se debe diseņar pensando en el futuro.
Cuando existe un modulo cliente que utiliza un modulo proveedor, se debe tratar de aplicar un
acoplamiento debil, en donde basta con que se pongan de acuerdo con la interfaz de programacion
que ambos comparten.

El concepto de interfaz no existe en C++, pero una clase abstracta puede ayudar a solucionar esta
omision del lenguaje.

Una clase abstracta es aquella donde algunos metodos no estan definidos, o se conoce como una 
clase que esta parcialmente definida. En consecuencia, una clase abstracta no tiene instancias.

Se define una clase abstracta por medio del concepto de funciones virtuales puras, que no tienen
codigo asociado.

Si una clase abstracta es tomada para herencia y se desea que objetos de la clase descendiente si
tengan instancias, se debe escribir el codigo asociado a la funcion virtual pura.

#ifndef __INSTRUMENTO__H
#define __INSTRUMENTO__H
//interfaz de programacion
class Instrumento {
  public:
     virtual char * tocar() = 0;
};
#endif

#ifndef __SALACONCIERTO__H
#define __SALACONCIERTO__H

#include <iostream>
#include "Instrumento.h"
//clase cliente de un instrumento que utiliza polimorfismo y un
//acuerdo por medio de una interfaz, el Instrumento en este caso
class SalaConcierto {
  public:
     void ejecucion(Instrumento & instr) {
        cout<<instr.tocar()<<'\n';
     }

};
#endif


#ifndef __PIANO__H
#define __PIANO__H
#include "Instrumento.h"
class Piano: public Instrumento {
  public:
    virtual char * tocar() {
       return "soy un piano";
    }
};
#endif

#ifndef __VIOLIN__H
#define __VIOLIN__H
#include "Instrumento.h"
class Violin: public Instrumento {
  public:
    virtual char * tocar() {
       return "soy un violin";
    }
};
#endif

#include "Violin.h"
#include "Piano.h"
#include "SalaConcierto.h"

main() {
   Violin v ;
   Piano p;

   SalaConcierto auditorio;

   auditorio.ejecucion(v);
   auditorio.ejecucion(p);
}



12. Plantillas (Templates)

En cualquier ambiente de programacion es comun encontrarse con algoritmos que son similares pero difieren en el tipo de dato que manejan.

La generalidad o genericidad es la capacidad de definir un algoritmo para cualquier tipo de dato.

En C++ existe el concepto de plantilla o template que permite definir clases que soporten cualquier tipo de dato para aplicar los metodos dentro de el.

#ifndef __COMPARADOR_H__
#define  __COMPARADOR_H__
  template <class T> class Comparador {
    private:
      T a;
      T b;
    public:
     bool cmp(){
        return a > b;
     }
     void setA(T x) {
        a=x;
     }
     void setB(T x) {
        b=x;
     }
  };
#endif
#include "Comparador.h"
#include <iostream>

class Comparable {
  private:
    double x;
  public :
     Comparable():x(0) { }
     Comparable(double v):x(v) { }
     bool operator>(Comparable & otro) {
         return x > otro.x;
     }
};
main() {
  Comparador<int> cmpInt;
  Comparador<float> cmpFlt;
  Comparador<Comparable> cmpRaro;

  cmpInt.setA(2);
  cmpInt.setB(1);
  cout<<cmpInt.cmp()<<'\n';
  cmpFlt.setA(3.1415);
  cmpFlt.setB(2.58);
  cout<<cmpFlt.cmp()<<'\n';
  cmpRaro.setA(Comparable(2.58));
  cmpRaro.setB(Comparable(3.1415));
  cout<<cmpRaro.cmp()<<'\n';
}


Los templates tambien son utilizados para crear clases denominadas contenedores.
En si, desde la perspectiva de C++ son clases normales, pero en significado son
usadas para almacenar una secuencia de objetos de cualquier tipo. Por esta
razon se usan los templates.

#ifndef __OBJETOFINANCIERO__
#define __OBJETOFINANCIERO__
//ObjetoFinanciero.H
//Representa el concepto de un objeto financiero que tiene como
//servicio valuar. El parametro T indica que el resultado de valuar puede
//ser de cualquier tipo
class ObjetoFinanciero {
 public:
   virtual double valuar() = 0;
};
#endif

#ifndef __BONO__
#define __BONO__
#include "ObjetoFinanciero.H"
   
class Bono : public ObjetoFinanciero {
 public:
   virtual double valuar()=0 ;
};
#endif

#ifndef __CUPONCERO__
#define __CUPONCERO__
#include "Bono.H"

class CuponCero : public Bono {
  private:
    double valorNominal;
    double tasaInteres;
  public:
    CuponCero():valorNominal(0),tasaInteres(0){}
    CuponCero(double vn,double ti):valorNominal(vn),tasaInteres(ti){}
    virtual double valuar();
};     
#endif  

#include "CuponCero.H"

double CuponCero::valuar() {
   double denominador(1+tasaInteres); 
   return valorNominal/denominador; //(1+tasaInteres);
}

#ifndef __ACCION__
#define __ACCION__
#include "ObjetoFinanciero.H"
class Accion: public ObjetoFinanciero {
  private:
        double beta;
        double tasaLibreRiesgo;
        double tasaMercado;
        double precioActual;
        double calcularRendimiento() ;
  public:

       Accion():
        precioActual(0),beta(0),tasaLibreRiesgo(0),tasaMercado(0){}
       Accion(double pr,double b,double tf,double tm):
        precioActual(pr),beta(b),tasaLibreRiesgo(tf),tasaMercado(tm){}
       virtual double valuar();
};
#endif

#include "Accion.H"

double Accion::calcularRendimiento() {
  double tasaRendimiento =0;

  tasaRendimiento = tasaLibreRiesgo + beta*(tasaMercado - tasaLibreRiesgo);
  return tasaRendimiento;
}
double Accion::valuar() {
  double valor = 0;
  valor = precioActual*(1+calcularRendimiento());
  return valor;
}

#ifndef __PORTAFOLIO__
#define __PORTAFOLIO__
#include "ObjetoFinanciero.H"
template <class T,int max> class Portafolio: public ObjetoFinanciero {
    private:
        T arreglo[max];
        int actual;
    public:
     Portafolio():actual(0){}
        void agregar(T& objeto) {
          if ( actual < max ) {
            arreglo[actual] = objeto;
            actual++;
          }
        }

        virtual double valuar() {
          double valor=0;
          for (int i=0;i<actual;i++) {
             valor += arreglo[i].valuar();
          }
          return valor;
        }
};
#endif

#ifndef __VALUADOR__
#define __VALUADOR__

#include "ObjetoFinanciero.H"
#include "Bono.H"
#include "CuponCero.H"
#include "Accion.H"
#include "Portafolio.H"
#endif

#include "Valuador.H"
#include <iostream.h>

main() { 
    
double tasaLibreRiesgo (0.1);
double tasaMercado (0.3);
Accion a1(10,0.1,tasaLibreRiesgo,tasaMercado);
Accion a2(15,0.15,tasaLibreRiesgo,tasaMercado);
CuponCero b1(10,tasaLibreRiesgo);
CuponCero b2(1,tasaLibreRiesgo);
Portafolio<CuponCero,8> port1;
Portafolio<Accion,8> port2;

port1.agregar(b1);
port1.agregar(b2);
cout<<port1.valuar()<<"\n";
port2.agregar(a1);
port2.agregar(a2); 
cout<<port2.valuar()<<"\n";
}



13. Herencia Multiple

En C++ la herencia multiple es posible aunque las reglas de uso se complican.

Para este ejemplo se van a suponer dos interfases IX e IY, y de ellas hace herencia una clase
denominada CA

#ifndef __IX_H__
#define __IX_H__

class IX {
  public:
        virtual void Fx1() =0;
        virtual void Fx2() =0;

};
#endif

#ifndef __IY_H__
#define __IY_H__

class IY {
  public:
        virtual void Fy1() =0;
        virtual void Fy2() =0;

};
#endif


#ifndef __CA_H__
#define __CA_H__
#include <iostream>
#include "IX.h"
#include "IY.h"
class CA : public IX, public IY {
  private:
     void p(char * msg) {
       cout << msg <<endl;
     }
  public:
     virtual void Fx1() {
        p("Fx1");
     }
     virtual void Fx2() {
        p("Fx2");
     }
     virtual void Fy1() {
        p("Fy1");
     }
     virtual void Fy2() {
        p("Fy2");
     }

};
#endif

#include "IX.h"
#include "IY.h"
#include "CA.h"
void testIX(IX & i) {
   i.Fx1();
   i.Fx2();
}
void testIY(IY & i) {
   i.Fy1();
   i.Fy2();
}

main() {
  CA c;
  testIX(c);
  testIY(c);
}


14. Objetos dinamicos

Hasta ahora, todos los ejemplos han usado objetos estaticos.
Un objeto estatico al ser declarado, invoca al constructor.
Existe otra manera y es utilizando dos operadores, new y delete

Por ejemplo, para el objeto CA se muestra el uso de new y delete

#include "CA.h"

main() {
  CA *pc = new CA();
  delete pc;
}


15. Copia de objetos

Tipicamente C++ utiliza la filosofia de copiar byte a byte el contenido de un objeto a otro, pero es posible cambiar este comportamiento por medio de sobrecarga de operadores.

Existen 3 casos donde se aplican las copias:
+ Cuando se declara un objeto
+ Cuando se pasa por valor
+ Cuando se asigna con el operador =

El siguiente programa muestra como los constructores y el operador =
son invocados.

//Copia.C
#include <iostream.h>

class A{
public:
  int x;
  A(int v):x(v){ cout <<"invocando A(int)"<<"\n";}
  A(const A& orig) {   cout <<"invocando A(A&)"<<"\n";x= orig.x; }
  A() { cout <<"invocando A()"<<"\n";
         x=0;} //necesario para pasarlo como parametro o asignar a otro objeto
  A& operator=(const A& orig){
         cout <<"invocando A="<<"\n";
        x=orig.x; return *this;}
};

class B{
public:
  char ch;
  A  obj;
  B() { cout <<"invocando B()"<<"\n";}
  B(A o,char c):ch(c){
        cout << "invocando B(A o,char c)"<<"\n";
        obj=o;
  }
  B(const B& orig){ cout<<"invocando B(B&)"<<"\n";
        ch=orig.ch;
        obj=orig.obj;
  }
  B& operator=(const B& orig) {
     cout <<"invocando B="<<"\n";
     obj = orig.obj;
     ch = orig.ch;
     return *this;
  }
};

main() {
 A o1(5);
 B o2(o1,'a');
 B o3 = o2;
 cout << o3.ch << " "<<o3.obj.x<<"\n" ;
 B o4;
 o4 = o3;
}
//Copia.C



16. Navegacion de Jerarquia de Clases.

Cuando se usan un conjunto de clases que estan dentro de una libreria de clases
o un framework, es necesario aplicar conversiones de tipos entre objetos.

Existe un mecanismo denomiando identificacion de tipos en tiempo de ejecucion
(Runtime type Identification o RTTI) que permite aplicar un chequeo con la
funcion typeid. Y tambien existen dos funciones tipo plantilla o template que
permiten aplicar conversiones, denominadas static_cast y dynamic_cast.

Existen dos tipos de conversiones. 
La primera es conversion de una clase especifica a una clase general  en
la jerarquia de herencia.
El siguiente ejemplo muestra este concepto:

//UpCast.C
#include <iostream.h>
class Figura { public: virtual void p() =0;};
class Circulo:public Figura {
  public:
   virtual void p() { cout<<"soy circulo"<<"\n"; }
};
class Cuadrado:public Figura {
   public:
   virtual void p() { cout<<"soy cuadrado"<<"\n";}
};
class Ajeno {
   public:
     void p() { cout <<"soy ajeno a la jerarquia"<<"\n";} };

void miniCAD(Figura * f) {
 f->p();
}
main() {
  Figura * pf;
  Circulo c;
  Circulo * pc = &c;
  miniCAD(pc);
   pf = static_cast<Figura *>(pc);
  miniCAD(pf);
  Cuadrado r;
  Cuadrado * pr = &r;
  pf = static_cast<Figura *>(pr);
  miniCAD(pf);
  Ajeno a;
  Ajeno *pa= &a;
//  pf = static_cast<Figura *>(pa);
//  miniCAD(pf);
}
//UpCast.C


La otra, que es comun cuando se utilizan clases de tipo contenedor basadas en
herencia o delegacion; consiste en convertir una referencia a una clase generica
a una clase especifica. Este paso puede tener un peligro dado que en tiempo de
ejecucion se puede obligar que un objeto se convierta a una clase de la cual no descienda o no le pertenezca.


//DownCast.C
#include <iostream.h>
class Figura { public: virtual void p() =0;};
class Circulo:public Figura {
  public:
   virtual void p() { cout<<"soy circulo"<<"\n"; }
};
class Cuadrado:public Figura {
   public:
   virtual void p() { cout<<"soy cuadrado"<<"\n";}
};
class Ajeno {
   public:
     void p() { cout <<"soy ajeno a la jerarquia"<<"\n";} };
Figura * upcast(Figura *p) {
   return p;
}
void miniCAD(Figura * f) {
 f->p();
}
main() {
  Figura * pf;
  Circulo c;
  Cuadrado r;
  Circulo * pc = &c;
  Cuadrado * pr = &r;
  pf = static_cast<Figura *>(pc);
  pf=upcast(pf);
  pc = static_cast<Circulo *>(pf);
  cout << pc << "\n";
  miniCAD(pc);
  pf = static_cast<Figura *>(pr);
  pf=upcast(pf);
  pr= static_cast<Cuadrado *>(pf);
  cout << pr << "\n";
  miniCAD(pr);
  pc = static_cast<Circulo *>(upcast(pr));
  cout << pc << "\n";
  miniCAD(pc);
  pc = dynamic_cast<Circulo *>(upcast(pr));
  cout << pc << "\n";
  if (pc) {
   miniCAD(pc);
  }
}
//DownCast.C


El error surge cuando se trata de convertir un apuntador de Figura que apunta
a un Rectangulo a un Circulo. La funcion static_cast aplica una conversion pero
no da el comportamiento adecuado.
La funcion dynamic_cast detecta el error y asigna un apuntador nulo 

17. Constantes y objetos compartidos

Un objeto puede ser declarado como constante cuando se desea almacenar datos de
solo lectura. Y los metodos que pueden ser invocados son de tipo const.
Un objeto constante es declardo como
const Clase objeto(...);

Y solo se pueden invocar metodos que tengan
tiporetorno metodo(...) const { ...}

Si se invocan metodos que no son const, el compilador retorna un error.
//Constante.C
#include <iostream.h>
class Constante {
  private:
        double valor;
  public:
        Constante(double v):valor(v){}
        double getValor() const { return valor;}
        double setValor(double v){  valor=v;}
};

main() {
  const Constante pi(3.14159);
  Constante cambiante(1);

  cout << pi.getValor()<<"\n";
  cout << cambiante.getValor()<<"\n";
//  pi.setValor(2.718);
  cambiante.setValor(2);
  cout << cambiante.getValor()<<"\n";
}
//Constante.C

Un atributo o metodo de una clase se puede calificar como estatico con el fin
de proporcionar un acceso sin tener que instanciar un objeto.

Esto permite compartir datos (escalares u objetos) entre clases o invocar 
metodos para empezar un contacto con una clase sin tener que instanciarla.

Para declar un atributo static
static Tipo atributoestatico;

Para iniciar un atributo static se debe seguir la siguiente sintaxis:
Clase Clase::atributoestatico(valor);
//Singleton.C
#include <iostream.h>

class Singleton {
private:
  static Singleton e;
  int i;
  Singleton(int ii) : i(ii) {}
public:
  static Singleton& nuevo() { return e; }
  int val() const { return i; }
};

Singleton Singleton::e(47);

int main() {
//  Singleton x(1);
  cout << Singleton::nuevo().val() << endl;
}
//Singleton.C

Observar aqui el uso del constructor privado, para evitar que se defina una
instancia de la clase

18. Clases anidadas

Se puede definir una clase que tenga dentro de ella otra clase anidada.

Y se pueden instanciar objetos de tipo la clase anidada de la siguiente manera
ClaseNivel0::ClaseNivel1 objeto( ... );


//Anidadas.C
#include <iostream.h>
class Externa {
private:
  char ch;
public:
  class Interna {
    private:
        static int constante;
        double f;
    public:
        Interna():f(0){}
        Interna(double v):f(v){}
        int getConstante() const { return constante; }
  };
  Externa(char c):ch(c){}
  char getCh() const{ return ch; }
  Interna & getRaro(){ return raro;}
private:
  Interna raro;
};

int Externa::Interna::constante(9);

main() {
  Externa ext('a');
  Externa::Interna in(3.14159);
  cout << ext.getCh() << endl;
  cout << in.getConstante() << endl;
  cout << ext.getRaro().getConstante()<<endl;
};
//Anidadas.C


19. Biblioteca estandar de plantillas (Standard Template Library)

En C++ se proporcionan una serie de clases que son estructuras de datos o
contenedores, y algoritmos para poder operar sobre dichas estructuras.

Estan basados en el concepto de plantillas y son consideradas un estandar, por
lo que se entregan con las implantaciones del compilador de C++. Se denominan
STL.

A continuacion se listan las estructuras, descripcion y archivos a incluir


string   cadenas de caracteres           string
vector   arreglo de tamaņo variable      vector.h
list     lista doblemente ligada         list.h
queue    cola                            queue
stack    pila                            stack.h
map      arreglo asociativo o hash       map.h


#include <string>
#include <vector.h>
#include <list.h>
#include <queue>
#include <stack.h>
#include <map.h>

main() {
 vector<string> vec(4); //vector de 4 elementos
 vec[0]="gus";
 vec[1]="chiquis";
 for (int i=0;i<vec.capacity();i++){
    cout<<vec[i]<<"\n";
 }
 map<string,double> hash;
 hash["vianney"]=10;
 hash["gaby"]=15;
 cout<<hash["vianney"]<<"\n";
 cout<<hash["gaby"]<<"\n";
 list<string> lista(10);

}


20. Herramientas.

Al desarrollar un programa existen varias actividades:

+ Compilacion, que consiste en checar sintaxis y generar modulos objeto
+ Enlazado de cada modulo objeto para construir un programa ejecutable o
una libreria estatica o dinamica.


El comando make ayuda a construir una serie de instrucciones de compilacion
y generacion de librerias y/o ejecutables

El comando ar sirve para guardar varios modulos objeto en un solo archivo

El comando ld sirve para generar librerias estaticas o dinamicas o ejecutables
Una libreria estatica es aquella que al generar un programa ejecutable se
enlaza de una manera fija o estatica al programa ejecutable.
Una libreria dinamica se carga en tiempo de ejecucion y no es necesario que este
ligado al programa ejecutable. El sistema operativo se encarga de ayudar a la
carga de la libreria en tiempo de ejecucion.

Retomando el ejemplo de la clase Valuador, se puede generar un archivo 
denominado valuador.mk, que es el que ejecuta con el comando make 

CXX = g++
CXXFLAGS = -I.
HXXFILES =  ObjetoFinanciero.H Bono.H Accion.H CuponCero.H Portafolio.H
CXXFILES = CuponCero.C \
        Accion.C \
        Valuador.C
ALLFILES =  $(CXXFILES) $(HXXFILES)

OBJS = \
        CuponCero.o \
        Accion.o

EXE = Valuador
LIB = libvaluador.a
DLL = valuador.so

$(LIB) : $(OBJS)
        ar ur $(LIB) $(OBJS)

LIBS= -L. -lvaluador

$(EXE): $(LIB) $(EXE).o
        $(CXX) -o $@ $@.o $(LIBS)

LINKER = $(CXX)
LINK_FLAGS =  -shared -nostdlib
dynamic: $(LIB)
        $(CXX)  -o $(DLL) $(LINK_FLAGS) $(OBJS)
        $(CXX)  -o $(EXE)_dyn $(EXE).o $(DLL)

all: $(EXE) dynamic

clean:
        rm $(OBJS)
        rm $(LIB)
        rm $(DLL)
        rm $(EXE)
        rm $(EXE)_dyn

Una libreria dinamica permite que un programa carge en tiempo de ejecucion y 
de funciones y/o clases.

Por ejemplo, se puede hacer una funcion de la siguiente manera

//dynhello.C
#include <iostream.h>

extern "C" void hello() {
    std::cout << "hello" << '\n';
}


//dynhello.C

Se tiene que declarar como extern "C" dado que es la unica manera que una 
libreria dinamica puede ser utilizada para cargar facilmente funciones. No
se recomienda el uso de funciones C++, dado que tienen un estilo de nombres
de la funcion distintos.

Compilarlo como
 g++ -o hello.so -shared -nostdlib dynhello.C

//maindynhello.C

#include <iostream.h>
#include <dlfcn.h>


int main() {
    void* handle = dlopen("./hello.so", RTLD_LAZY);
    
    if (!handle) {
        cerr << "no se puede abrir libreria ... " << dlerror() << '\n';
        return 1;
    }
    

    cout << "Cargando simbolo hello...\n";
    typedef void (*hello_t)();
    hello_t hello = (hello_t) dlsym(handle, "hello");
    if (!hello) {
        cerr << "No se puede cargar simbolo 'hello': " << dlerror() <<
            '\n';
        dlclose(handle);
        return 1;
    }
  
    hello();
    
    // close the library
    dlclose(handle);
}
//maindynhello.C

Tambien se pueden utilizar clases y hacer uso del polimorfismo con librerias
dinamicas.



21. Ejercicio.