witam wszystkich,

ostatnio stanalem przed pewnym problemem, ktory nie wiem jak elegancko
rozwiazac, mianowicie mam cos takiego:

template<class T> TSth
{
int _value;
public:
int GetValue() const { return _value }
};

teraz, mam takie klasy:
class A : public Sth<A> {};
class B : public A, public, Sth<B> {};
po prostu, moze zaistniec klasa, ktora dziedziczy wiecej niz raz z tego
template, ale z innym typem.

w tym przypadku:
A a;
a.GetValue(); // bez problemu
B b;
b.GetValue() // ambigious access...

chcialbym moc wykonac cos w stylu:
b.GetValue<A>();
b.GetValue<B>();
moc odczytac wartosc z pewnego typu, z ktorego dziedziczy moje b. ale
niekoniecznie dokladnie tak, po prostu cos, co wygladalo by lepiej niz:
((TSth<A>*)&b).GetValue();
((TSth<B>*)&b).GetValue();
co jest brzydkie i niebezpieczne, bo casty sa static, trzeba by uzywac
dynamic_cast do kazdego wywolania GetValue(), co z kolei nie wydaje sie
eleganckie, bo trzeba by sprawdzac czy na pewno nie jest NULL, etc.
mozna naturalnie owinac to we funkcje ale nie o to chodzi, to nie
zmienia faktu, ze ten dynamic_cast tam bedzie sobie siedzial.

probowalem dodac do Sth cos takiego:
template<class U>
int GetValue()
{
return Sth<U>::_value;
}
wtedy, dla jednakowych U i T kompilator nie powinien protestowac. ale
czy to ma sens? czy ktos z grupowiczow moglby zaproponowac jakies inne
rozwiazanie?

pozdrawiam
Marcin.