personaje, el 20 de diciembre a las 14:43 me escribiste:
> On Dec 20, 2007 2:35 PM, Leandro Lucarella <[EMAIL PROTECTED]> wrote:
> > personaje, el 20 de diciembre a las 13:43 me escribiste:
> > > > No. Y no tiene sentido, cuando llames a c.Run(1) a cual llama? Y si no
> > > > llamás a los Run del padre, menos sentido le veo.
> > >
> > > la idea es así:
> > >
> > > A* pa;
> > > B* pb;
> > > C* pc = new C;
> > >
> > > pa = pc;
> > > pb = pc;
> > >
> > > pa->Run(); // corre la versión A
> > > pb->Run(); // corre la versión B
> >
> > Entonces vos no querés que sea virtual! El virtual es justamente lo que
> > hace que pa->Run() llame a C::Run en vez de a A::Run!
>
> nono, quiero reimplementar los métodos, pero que sean distintos según
> venga el llamado por un puntero A o B...
Vos lo que necesitás es un cura entonces =P
> es completamente bizarro y como ya vimos antes, no se puede... pero
> tenía esperanza de algún truquillo :(
Si no tenés miedo de ir al infierno, podés hacer algo así:
#include <cstdio>
struct A
{
const char* n;
A(const char* n): n(n) { printf("A::A(%s)\n", n); }
virtual ~A() { printf("A::~A(%s)\n", n); }
void f() { fA(); }
virtual void fA() { printf("A::fA()\n"); }
};
struct B
{
const char* m;
B(const char* m): m(m) { printf("B::B(%s)\n", m); }
virtual ~B() { printf("B::~B(%s)\n", m); }
void f() { fB(); }
virtual void fB() { printf("B::fB()\n"); }
};
struct C: A, B
{
C(const char* n): A(n), B(n) { printf("C::C(%s)\n", n); }
~C() { printf("C::~C(%s)\n", n); }
void fA() { printf("C::fA()\n"); }
void fB() { printf("C::fB()\n"); }
};
int main()
{
A* pa;
B* pb;
C c("c");
pa = &c;
pb = &c;
pa->f();
pb->f();
return 0;
}
Esto te va a imprimir, como esperás:
A::A(c)
B::B(c)
C::C(c)
C::fA() <-- llama a las redefiniciones de C
C::fB() <-- llama a las redefiniciones de C
C::~C(c)
B::~B(c)
A::~A(c)
Es extremadamente no extensible, y siendo que vos decís que las clases
bases son especializaciones de un mismo template, calculo que no te sirve,
pero eso se arregla haciendo que la f virtual tome un parámetro (algo como
puntero a la clase en cuestión creo que hace cerrar todo bastante lindo,
considerando las condiciones del problema =P).
Esto también anda:
#include <iostream>
template < typename T >
struct A
{
T n;
A(T n): n(n) { std::cout << "A::A(" << n << ")\n"; }
virtual ~A() { std::cout << "A::~A(" << n << ")\n"; }
void f() { vf(this); }
virtual void vf(A*) { std::cout << "A::vf(" << n << ")\n"; }
};
struct C: A<int>, A<char>
{
C(char n): A<int>(n), A<char>(n) { std::cout << "C::C(" << n << ")\n"; }
~C() { std::cout << "C::~C(" << A<char>::n << ")\n"; }
void vf(A<int>*) { std::cout << "C::vf(A<int> n=" << A<int>::n <<
")\n"; }
void vf(A<char>*) { std::cout << "C::vf(A<char> n=" << A<char>::n <<
")\n"; }
};
int main()
{
A<int>* pa;
A<char>* pb;
C c('c');
pa = &c;
pb = &c;
pa->f();
pb->f();
return 0;
}
Esto imprime, como es de esperarse (al menos para Satanás):
::A(99)
A::A(c)
C::C(c)
C::vf(A<int> n=99)
C::vf(A<char> n=c)
C::~C(c)
A::~A(c)
A::~A(99)
Al final estoy "eligiendo" el método a llamar, a través del tipo del
puntero con el cual lo llamo (spooky! =P), que creo que era lo que vos
querías.
Y si sos macabro podés seguir agregando cosas, por ej:
struct C: A<int>, A<char>, A<float>, A<std::string>
{
// ...
void vf(A<int>*) { /* ... */ }
void vf(A<char>*) { /* ... */ }
void vf(A<float>*) { /* ... */ }
void vf(A<std::string>*) { /* ... */ }
// ...
};
--
Leandro Lucarella (luca) | Blog colectivo: http://www.mazziblog.com.ar/blog/
----------------------------------------------------------------------------
GPG Key: 5F5A8D05 (F8CD F9A7 BF00 5431 4145 104C 949E BFB6 5F5A 8D05)
----------------------------------------------------------------------------
Can you stand up?
I do believe it's working, good.
That'll keep you going through the show
Come on it's time to go.
_______________________________________________
Lista de correo Programacion.
[email protected]
http://listas.fi.uba.ar/mailman/listinfo/programacion
