[conception] spécialisation de paramètres de fonctions héritées

Bonjour à tous,

j'ai un petit problème de conception, et je ne sais pas trop comment le résoudre de façon élégante.

J'ai une classe mère (virtuelle) IResponse et plusieurs classes filles qui l'implémentent:

Code:

---

1 2 3 4 5 6 7 8 9 10

class IResponse { //... };   class Response1 : public IResponse { // ... };

---

Ensuiet, j'ai une classe mère (virtuelle) IRequest qui définit une fonction membre process().
J'ai plusieurs classe filles qui implémentent IRequest:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

class IRequest { // [...] virtual int process() = 0; };   class Request1 : public IRequest { // [...] int process(); }

---

Jusqu'ici, tout va bien.
Je voudrais maintenant que ma méthode process prenne un IResponse en paramètre, mais que ce paramètre soit spécialisé pour les spécialisations de IRequest::process.
En gros, je voudrais faire ça:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

class IRequest { // [...] virtual int process(IResponse &response) = 0; };   class Request1 : public IRequest { // [...] int process(Response1 &response); }

---

Le problème, c'est que si je fais ça, j'ai cru comprendre que je ne fais que surcharger process, mais que je ne l'implémente pas.

Vous voyez ce que je cherche à faire? (c'est pas évident à expliquer)

Je ne pense pas que cette "covariance sur une autre classe" soit possible.
Si tu veux redéfinir la fonction virtuelle, tu seras obligé de downcaster (avec static_cast<> ou dynamic_cast<>, mais ni un cast C ni reinterpret_cast<>), ou bien de travailler seulement sur l'interface.

Es-tu sûr d'avoir besoin d'accéder au type Request1 ?

Tu ne peux pas etre covariant sur les parametres, uniquement sur le type de retour.

Si on est covariant sur les parametres, il faut verifier la coherence des types a l'execution. Tu peux utiliser dynamic_cast pour le simuler.

Note: on peut etre contra-variant sur les parametres et conserver la possibilite d'une verification statique des types, mais ce n'est pas disponible en C++.

Citation:

---

Envoyé par Médinoc

Es-tu sûr d'avoir besoin d'accéder au type Request1 ?

---

Oui car je dois remplir les champs de Request1. Et ils sont différents de Request2.

Citation:

---

Envoyé par Jean-Marc.Bourguet

Tu ne peux pas etre covariant sur les parametres, uniquement sur le type de retour.

---

Je pourrais donc faire:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

class IRequest { // [...] virtual IResponse* process() = 0; } ;   class Request1 : public IRequest { // [...] Response1* process(); }

---

?

Citation:

---

Envoyé par r0d

Je pourrais donc faire:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

class IRequest { // [...] virtual IResponse* process() = 0; } ;   class Request1 : public IRequest { // [...] Response1* process(); }

---

?

---

Oui.

Ok merci. Je vais faire comme ça alors. Mais j'ai l'impression que ce n'est pas trés "propre" comme façon de faire non?

Si c'est pour allouer et initialiser, tu peux directement retourner une IResponse, si tu juges ça plus propre.

Citation:

---

Envoyé par r0d

Ok merci. Je vais faire comme ça alors. Mais j'ai l'impression que ce n'est pas trés "propre" comme façon de faire non?

---

Une classe derivee peut offrir des post-conditions plus forte que la classe de base (c'est la co-variance sur le resultat) et avoir besoin de pre-conditions plus faibles (c'est la contra-variance sur les parametres). Je ne vois pas en quoi ce n'est pas propre d'utiliser ce fait. Ce n'est pas different que

Code:

---

1 2 3 4 5 6

class Request1 : public IRequest { // [...] IResponse* process() { return request1Process(); } Response* request1Process() {... } };

---

et d'utiliser request1Process quand tu as une instance de Request1 (a part le comportement dispatche pour les classes deriviees de Request1).

Ok.

:merci: à vous :D