c++ ed ereditarietà

[zioluter]

ciao,
ho una gerarchia del tipo
class A{
public:
bla bla...
}

class C{
public:
virtual ~C(){},
virtual void foo()=0;
}

class B: public class A, public class C{
public:
virtual void foo(){
//bla blaa...
}
}

in un metodo della mia applicazione ricevo un puntatore A* che però punta ad una istanza di B, che io però vorrei chiamare castandolo a C (Esistono varie classi che implementano C)
quindi ho:
.....
A* a;
......assegnamento di a......
C* c = (C*)a;
c->foo(); //dà luogo a chiamate inconsistenti...

cosa sbaglio? In java (mondo da cui provengo se C fosse un'interfaccia, sarebbe tutto perfettamente lecito..)
grazie!

[XWolverineX]

Da una rapida lettura il tuo codice non funziona perchè le classi A e C non hanno nessuna relazione tra loro. Dovresti derivare C da A, e derivare B da A e C in modo virtual.

Ripeto, da una rapida lettura, può darsi anche che abbia capito tutt'altra cosa.

[zioluter]

penso proprio che tu abbia ragione: in effetti A e C non appartengono alla stessa gerarchia. Sono rimasto però colpito da questo, perchè in java è perfettamente lecito e funziona (ok C è un'interface però..). Il problema è che è questa la semantica che il codice dovrebbe avere, quindi mi chiedevo, dato

A
| C
| |
|--------
B

se ci sia modo di ottenere un valido puntatore a C, dato A (Che in realtà punta a una istanza di B....)
Come mi ha giustamente suggerito funziona, il problema è che in realtà C è un handler che B implementa e che non ha a che fare con la gerarchia A-B, inoltre non posso toccare il codice di A (legacy).
grazie.

[XWolverineX]

Se non vuoi fare una gerarchia, ti consiglio di usare l'overloading degli operatori.
Farai un overloading dell'operatore di cast e all'interno della tua funzione troverai il modo di trasformare la classe A in una classe C

esempio

class A
{
      friend void operator C*() {Trasforma la tua classe qui}
  //metodi e dati

}

In questo modo, il compilatore saprà cosa fare quando incontrerà

C *p = (C*)A;

[shodan]

Se A possiede almeno una funzione virtual è meglio un dynamic_cast.

class IBase { // interfaccia esposta da C
	public:
		virtual ~IBase()=0;
		virtual void func1()=0;
		virtual void outval()=0;
};
IBase::~IBase(){;}

class Legacy { // A
	public:
		virtual ~Legacy() {;}
		void func2() { cout << "Legacy" << endl ; val = 3; }
		int val;
		void printVal() { cout << val << endl; }
};

class Final : public Legacy, public IBase { // B
	public:
		~Final(){}
		void func1() { func2(); }
		void outval() { printVal(); }
};

int main(int argc, char* argv[]) {
	Final f;
	Legacy* a = &f;
	IBase* ib = dynamic_cast<Final*>(a);

	if (ib) {
		ib->func1();
		ib->outval();
	}
}

[zioluter]

ok ragazzi,
grazie a tutti per i suggerimenti
Paolo