CLASES ABSTRACTAS

Una clase abstracta, o clase base abstracta (ABC), es una que est diseada slo como
clase padre de las cuales se deben derivar clases hijas. Una clase abstracta se usa para representar
aquellos mtodos que despus se implementarn en las clases derivadas, pero la clase abstracta
en s no contiene ninguna implementacin, solamente representa los mtodos que se deben
implementar. Por ello, no es posible instanciar una clase abstracta, pero s una clase concreta que
implemente los mtodos definidos en ella.

Una clase abstracta tiene una caracterstica importante: No puede haber objetos de esa clase. En
vez de eso, una clase abstracta debe ser usada solo como una base que otras clases heredaran.

Las clases abstractas son tiles para definir interfaces, es decir, un conjunto de mtodos que
definen el comportamiento de un mdulo determinado. Estas definiciones pueden utilizarse sin
tener en cuenta la implementacin que se har de ellos.

Reglas de uso:

Una clase abstracta solo puede ser usada como clase base para otras clases,
pero no puede ser instanciada para crear un objeto.

Una clase abstracta no puede ser utilizada como argumento o como retorno de una
funcin.

Si puede declararse punteros a clase abstracta.

Se permiten referencias a clase abstracta, suponiendo que el objeto temporal no es

necesario en la inicializacin.

Ejemplo:

class Abstracta{
public:
virtual int metodo() = 0;
};
class ConcretaA : public Abstracta{
public:
int metodo() {
//haz algo
}
};
class ConcretaB : public Abstracta{
public:
int metodo() {
//otra implementacin
}
};
 FUNCIONES VIRTUALES
Una funcin virtual es una funcin que es declarada como 'virtual' en una clase base y es redefinida en
una o ms clases derivadas. Adems, cada clase derivada puede tener su propia versin de la funcin
virtual.

Se declara una funcin como virtual dentro de la clase base precediendo su declaracin con la palabra
clave virtual. Cuando una funcin virtual es redefinida por una clase derivada, la palabra clave 'virtual'
no necesita ser repetida (aunque no es un error hacerlo).
Una clase que incluya una funcin virtual es llamada una 'clase polimrfica'. Este trmino tambin aplica
a una clase que hereda una clase base conteniendo una funcin virtual.
LAS FUNCIONES VIRTUALES SON HEREDADAS
Una vez que una funcin es declarada como virtual, esta se mantiene virtual sin importar
cuantas capas de clases derivadas esta debe perdurar.
Cuando una clase derivada no redefine una funcin virtual, entonces la funcin, como se
definicin en la clase base, es usada. Ejemplo:
#include <iostream>
class base {
public:
virtual void quien() {
cout << "Base\n";
}
};
class primera_d : public base {
public:
void quien() {
cout << "Primera derivacion\n";
}
};
class segunda_d : public base {
public:
// quien () no definida
};
int main() {
base obj_base;
base *p;

primera_d obj_primera;
segunda_d obj_segunda;

p = &obj_base;
p->quien(); // acceder a quien() en 'base'

p = &obj_primera;
p->quien(); // acceder a quien() en 'primera_d'
 p = &obj_segunda;
p->quien(); /* acceder a quien() en 'base'
porque segunda_d no la redefine */

return 0;
}

Mantenga en mente que las caractersticas heredadas de 'virtual' son jerrquicas. Por
tanto,, si el ejemplo precedente es modificado para que 'segunda_d' sea derivada de
'primera_d' en vez de 'base', entonces cuando quien() es referenciada relativa a un objeto
del tipo 'segunda_d', es la versin de 'quien()' declarada dentro de primera_d' la que es
llamada ya que es la clase ms cercana a 'segunda_d', no 'quien()' dentro de base.
Ejemplo:

#include <iostream>

class base {
public:
virtual void quien() {
cout << "Base\n";
}
};

class primera_d : public base {

public:
void quien() {
cout << "Primera derivacion\n";
}
};

// segunda_d ahora hereda primera_d -- no base.

class segunda_d : public primera_d {
// quien () no es definida.
};

int main()
{
base obj_base;
base *p;

primera_d obj_primera;
segunda_d obj_segunda;
 p = &obj_base;
p->quien(); // acceder a 'quien()' en 'base'.

p = &obj_primera;
p->quien(); // acceder a 'quien()' en 'primera_d'.
_
p = &obj_segunda;
p->quien(); /* acceder a 'quien()' en 'primera_d'
porque 'segunda_d' no la redefine */

return 0;
}
PORQUE USAR FUNCIONES VIRTUALES

Como se declaraba en el inicio de este captulo, las funciones virtuales en combinacin con
tipos derivados le permiten a C++ soportar polimorfismo en tiempo de ejecucin. El
polimorfismo es esencial para la programacin orientada a objetos por una razn: Esta
permite a una clase generalizada especificar aquellas funciones que sern comunes a
todas las derivadas de esa clase, mientras que permite a una clase derivada definir la
implementacin especfica de algunas o todas de esas funciones. A veces esta idea es
expresada como: La clase base dicta la 'interfaz' general que cualquier objeto derivado de
esa clase tendr, pero permite a la clase derivada definir el mtodo actual usado para
implementar esa interfaz. De ah que la frase "una interfaz mltiples mtodos" sea usada a
menudo para describir el polimorfismo.

Funciones Virtuales Puras

Una 'funcin virtual pura' es una funcin declarada en una clase base que no tiene
definicin relativa a la base. Como resultado, cualquier tipo derivado debe definir su
propia versin -- esta simplemente no puede usar la versin definida en la base. Para
declarar una funcin virtual pura use esta forma general:

virtual 'tipo' 'nombre_de_funcion'(lista_de_parametros) = 0;

Aqu, 'tipo' es el tipo de retorno de la funcin y 'nombre_de_funcion' es el nombre de la

funcin. Es el = 0 que designa la funcin virtual como pura. Por ejemplo, la siguiente
versin de 'figura', 'mostrar_area ()' es una funcin virtual pura.

class figura {
double x, y;
public:
void set_dim(double i, double j=0) {
x = i;
y = j;
}
virtual void mostrar_area() = 0; // pura
};
Declarando una funcin virtual como pura, se fuerza a cualquier clase derivada a definir su
propia implementacin. Si una clase falla en hacerlo, el compilador reportara un error.