Post by AnexusPost by MatÃas CostaCreo que hablas de «templates» ya que no hay interfaces en C++. Eso es de
java.
No hablo de templates, hablo de "interfaces en C++" o sea clases en
las que se definen metodos publicos virtuales "puros", es decir, no se
implementan y despues, la clase concreta que quieras hacer hereda de
ese "interface" e implementa sus metodos.
Ya se que en java existen, pero en C++ tambien, si no no hubiera hecho
la pregunta ;)
Post by MatÃas CostaCreo que no soy maleducado al decirte que es un tema demasiado extenso como
para explicarlo en un post. Bien buscas el pdf de «Thinking in C++» de un
tal Bruce Eckel (Mindview) o bien mandas un ejemplo concreto sobre el que
apuntar fallos.
No eres maleducado en absoluto. El tema de templates ya lo tengo muy
masticado y el Thinking in C++ ya lo tengo leido (los dos volumenes,
algo toston), concretamente en el segundo volumen aparece una
referencia a los "interfaces" solo que en el libro los llama "Clases
Virtuales Base".
Ejemplo no puedo mandar pues no me ha surjido la duda por un error en
ningun programa, si no porque me interesa saber hasta que punto es
factible o simplifica o simplemente que ventajas tiene el usar
interfaces en programacion con C++ asi como una explicacion banal o
ejemplo simple sobre su creacion y uso.
Pues, la definición de un interfaz es interesante en cualquier
lenguaje y tan bien en programación OO que en otra. Es un tema
fundamental de la programación modular, es decir, descomponer un
programa grande en modulos de tamaño manejable.
La cuestion es que no sirve de nada hacer modulos si siguen haciendo
referencias a otros en cuantidad y en todas las dirrecciones: se puede
quedar con programas spagghetti, salvo con spagghetti mas gruesos.
La solución es definir interfaces claros y "pequeños", y conectar
entre modulos solo pasando por estos interfaces. Lo que hace que las
dependencias entre modulos estan claramente documentadas por el
interfaz, con consequencia que es factible cambiar la implementación
de un modulo defectuoso (o simplemente corregir un bug) sin efecto
nefaste en los otros modulos por tanto que se conservan las reglas de
interfaz consensuado.
Ponemos un ejemplo sencillo: Los números complejos pueden escribirse
a+b*i o rho*e^(i*theta). La primera forma es mejor cuado se suma, la
secunda cuando se multiplica. Si se maneja complejos sin un interfaz
abstracto, todos los modulos que los usan pueden depender de la forma
que se elige. Pero si aparece finalmente que una otra implementación
sería mejor, estamos estancados porque tendriamos que cambiar todo el
programa por cambiarlo. Introduciendo un interfaz abstracto tal:
class complex {
private:
static complex _factory;
public:
static complex make_complex(void){_factory.make_brother();}
virtual complex make_brother(void)=0;
virtual void set_cartesian(double realpart,double imagparg)=0;
virtual void set_eulerian(double modulo,double theta)=0;
virtual double realpart(void)=0;
virtual double imagpart(void)=0;
virtual double modulo(void)=0; // rho
virtual double angulo(void)=0; // theta
virtual double operator+(/*...*/)=0;
virtual double operator*(/*...*/)=0;
};
se puede luego elegir una implementación o otra:
class cartesian_complex : public complex {
protected:
double _realpart,_imagpart;
public:
virtual complex make_brother(void);
virtual double realpart(void);
virtual double imagpart(void);;
virtual double modulo(void);
virtual double angulo(void);
virtual double operator+(/*...*/);
virtual double operator*(/*...*/);
};
class eulerian_complex : public complex {
protected:
double _rho,_theta;
public:
virtual complex make_brother(void);
virutal double realpart(void);
virtual double imagpart(void);;
virtual double modulo(void);
virtual double angulo(void);
virtual double operator+(/*...*/);
virtual double operator*(/*...*/);
};
simplemente con:
complex::_factory=new cartesian_complex;
o:
complex::_factory=new eulerian_complex;
se podría cambiar la clase de complejos creados, sin otra referencia a
las clases concretas.
--
__Pascal_Bourguignon__ . * . .*
http://www.informatimago.com/ * . . /\ ( . . *
. . / .\ . * .
.*. / * \ . .
. /* o \ .
* '''||''' .
******************