[c++]virtual?

[giuseppe500]

ciao.
Ho un grafo in cui posso agganciare elementi node e drawablenode.
node deriva da spatial, e drawablenode da node.
e' uno scenegraph che mi serve per renderizzare una scena , appunto composta da questi elementi.
Esaminiamo il caso in cui tutti gli elementi sono Drawablenode.

Dentro una classe in cui faccio il rendering attraverso il grafo.
parte che non funziona:

 if (iTop == -1)
{
if(((Geometry*)akVisible[i].Object)->GetParent())
((DrawableNode*)akVisible[i].Object->GetParent())->DrawNode(this,((Geometry*)akVisible[i].Object));

}

getparent è una funzione di spatial , da cui deriva node e da node drawablenode.

inline Spatial* Spatial::GetParent ()
{
    return m_pkParent;
}

mentre in drawablenode, drawnode è virtuale:

virtual void DrawNode(Renderer* pRenderer, Geometry* pGeometry);

infine da drawablenode deriva decorator che implementa questa funzione:

 void DrawNode(Renderer* pRenderer, Geometry* pGeometry);

il problema è che quando ho una classe decorator non riesco ad innescare il polimorfismo sulla classe decorator,e lanciare la funzione DrawNode di decorator.

ho 2 dubbi:
1)è giusto il cast a drawablenode* o trasforma tutto quello che ho in un drawablenode?compresi i decorator

((DrawableNode*)akVisible[i].Object->GetParent())->DrawNode(this,((Geometry*)akVisible[i].Object));

2)la fuzione che ritorna, o dovrebbe ritornare decorator non lo fa :
inline Spatial* Spatial::GetParent ()
{
return m_pkParent;
}
guardando nel debug la classe è sempre drawablenode.
perchè?
grazie

[giuseppe500]

pardon.
Il problema era che creando un nuovo Node (DrawableNode) vi erano alcune funzioni con ad es:

if (pkChild)
  {
       pkChild->SetParent(this);
   }

che non erano implementate nelle classi derivate , naturalmente non essendo implementate quel this era this di Node e non ad es di DrawableNode.

scusate per la svista.

mi sorge pero un nuovo problema:

if (pkChild)
{
   pkChild->SetParent(this);
 }

è possibile risolvere questo con un template?
mi spiego meglio:
ho due classi come dicevo precedentemente Node e DrawableNode , che sono essenzialmente uguali tranne alcune funzioni , con le mie(scarse)conoscenze ho ereditato DrawableNode da Node e implementato alcune funzioni .
Il problema principale è che devo riscrivere tutto 2 volte proprio per l'esempio riportato appena sopra del this.
il due volte potrebbe diventare n volte.
e soprattutto vorrei poter scegliere di utilizzare una casistica (tutti Node) o l'altra (tutti DrawableNode) è un caso in cui i template possano dare una mano?
se si come risolvere ?
grazie.

[giuseppe500]

up

[shodan]

Originariamente inviato da giuseppe500
è possibile risolvere questo con un template?

Di primo acchito risponderei: no, pkChild non è un valore noto a compile time.
Però si dovrebbe vedere il contesto di quel codice.

[giuseppe500]

mi sono spiegato un po male , volevo sapere se anziche usare la derivazione per il drawablenode che deriva da node, fosse possibile creare due tipi separati completamente ,ma utilizzare il codice comune delle due classi e implementare solo il codice differente per specializzazione.
E ' una cosa che non riesco a farmi entrare in testa quello della derivazione e della specializzazione con template.

dato che conosco compile time il tipo (node o drawablenode) che devo utilizzare,
oltre ad altri vantaggi avrei penso anche il vantaggio di prestazioni , dato che non devo usare il polimorfismo .

ciao shodan.

[shodan]

Se devi specializzare un template, il codice comune va riscritto per ogni specializzazione (altrimenti tanto vale derivare) e l'interfaccia dev'essere la stessa tra i due tipi di nodo (comprese le funzioni vuote).
Questo perché un eventuale oggetto che usa un'istanza di quel template si aspetta di usare un set di funzioni preciso senza doversi preoccupare di cosa effettivamente sia quell'oggetto (se Node o DrawableNode o altro).
Tra l'altro passare da un tipo all'altro con un cast è a tuo rischio e pericolo visto che i due nodi non hanno nessuna relazione tra loro.
Potresti postare le interfaccie dei nodi con lo schema di derivazione e le dichiarazioni delle funzioni?