Discussion :

[poukill]

Salut à tous!

Une petite question simple:

Soit une classe A définissant "une interface":
Soit B une classe fille de A, avec en plus une méthode spécialisée, n'exstant pas dans A:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
class A
{
  foo();
};
 
class B : public A
{
  foo2();
};

main.cpp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
int main()
{
  A * a;
  a->foo2(); // Impossible ?
}

Le downcasting n'est pas implicite ?
Sachant qu'on est sur d'avoir affaire à un objet B? J'ai essayé avec un dynamic_cast, mais le compilo veut rien savoir !

EDIT : Résolu avec:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
int main()
{
  A * a;
  dynamic_cast<B>(a)->foo2();
}

[Laurent Gomila]

Sachant qu'on est sur d'avoir affaire à un objet B?

Vraiment ? Dans l'exemple que tu donnes je ne sais pas comment tu fais pour savoir que a est un B.
Le downcasting n'est jamais implicite, puisque le compilo n'a aucun moyen de connaître le type dynamique de l'objet. Ca ne s'appelle pas "type dynamique" pour rien

J'ai essayé avec un dynamic_cast, mais le compilo veut rien savoir !

Montre nous ton code. Il y a aussi des exemples dans la FAQ, au cas où.

[poukill]

Oui Laurent, l'exemple n'était que pour montrer... Devant la complexité du programme, j'ai cracké!

En fait, dans une classe je suis sur d'avoir affaire à un type B, et donc un dynamic_cast est obligatoire pour pouvoir utiliser ces méthodes...

Merci et désolé pour le dérangement inutile...

PS : il est temps que ce projet se termine !

[Laurent Gomila]

En fait, dans une classe je suis sur d'avoir affaire à un type B, et donc un dynamic_cast est obligatoire pour pouvoir utiliser ces méthodes...

En fait dynamic_cast n'est utile que pour t'assurer que le type dynamique est bon (renvoie NULL ou lève une exception si ce n'est pas le cas). Mais si tu es certain que c'est un B, un static_cast suffira et t'épargera la perte de performance dûe à dynamic_cast.

Ou encore mieux : boost.polymorphic_cast, qui utilise dynamic_cast en debug et static_cast en release.

[poukill]

Merci !
J'adopte static_cast !

[Alp]

Si tu es sur d'avoir un B*, et que ca ne peut en être autrement, utilise un B*.
Mais bon, static_cast est ici le mieux.

[poukill]

Si tu es sur d'avoir un B*, et que ca ne peut en être autrement, utilise un B*.
Mais bon, static_cast est ici le mieux.

Bien sûr, mais c'est plus compliqué que ça...
J'ai une classe Gen:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
class Gen
{
public:
   virtual method() { m_mat->foo(); }
 
protected:
   A *m_mat;
}

Et j'ai plusieurs dérivées à la classe Gen : Gen1, Gen2, Gen3...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
class Gen3 : public Gen
{
public:
  virtual method() { m_mat->foo2(); } //un peu différent ici
}

ici la classe Gen3 n'utilise que B, c'est comme ça !
Je ne pense pas qu'il y aie d'autre moyen que faire un static_cast<B*> ?

[Laurent Gomila]

Je ne pense pas qu'il y aie d'autre moyen que faire un static_cast<B*> ?

Dans ce cas non, effectivement.

[poukill]

C'est bien ce que je pensais, merci !