methodes virtuelles + héritage multiple = collisions

bonjour à tous

j'ai un petit problème qui est le suivant : dans le cas d'un héritage multiple, comment faire quant on a des collisions (?) de nom de methodes virtuelles ?

example :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

class Server { ... public virtual void receivedPacket(char* packet, int size) = 0; };   class Client { ... public virtual void receivedPacket(char* buffer, int size) = 0; };   class TestServer : public Server { public void receivedPacket(char* buffer, int size) {} };   class TestClient : public Client { public void receivedPacket(char* buffer, int size) {} };

---

jusque là tout est bien
maintenant je veux faire un serveur non dédié, càd qui soit Client et Serveur en meme temps :

Code:

---

1 2 3 4 5 6

class TestNonDedicatedServer : public Server, Client {   // bon alors c'est le serveur ou le client qui recoit le packet ? public void receivedPacket(char* buffer, int size) {} };

---

vous voyez ?
vous vous doutez bien que je ne veux pas renommer mes methodes en receivedPacket_Server ou ajouter un argument ou je ne sais quoi de sémantiquement inacceptable...

merci ;)

Voir l'héritage virtuel.

Je ne vois pas trop ce que l'héritage virtuel peut résoudre dans ce cas. La solution passe souvent dans ce genre de situation par la création de classes intermédiaires (NonDedicatedServerServerSide et NonDedicatedServerClientSide par exemple, qui chacunes redéfinissent la fonction virtuelle, et la classe NonDedicatedServer qui hérite de ces deux classes intermédiaires).

je vois ce que tu veux dire JolyLoic (en gros "rediriger" les methodes qui entrent en collision), c'est un poil décevant quant meme qu'il n'y ait pas un moyen plus simple, du style

Code:

---

1 2 3

public void (Client) receivedPacket(char* buffer, int size) {} public void (Server) receivedPacket(char* buffer, int size) {}

---

pas la peine d'essayer hein ;)

En fait ça marche très bien.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

#include <iostream>   struct Server { virtual void receive() = 0; };   struct Client { virtual void receive() = 0; };     struct TestNonDedicatedServer : public Server, public Client { void receive() { std::cout << "TestNonDedicatedServer::receive" << std::endl; } };   int main() { TestNonDedicatedServer s; static_cast<Server&>(s).receive(); static_cast<Client&>(s).receive(); }

---

Aucun problème.

Passer par des classes intermédiaires permet de fournir un comportement différent quand on utilise cet objet depuis une interface serveur ou une interface client.

Citation:

---

Envoyé par loufoque

En fait ça marche très bien

---

en fait la fonction receive() est appellée depuis Server et Client, donc pour les cast c'est loupé ;)
je met résolu, JolyLoic a raison ;)

j'ai fait comme ca

Code:

---

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

class NonDedicatedServerServerSide : public Server { public: void receive(char* b, int s) { ... } };   class NonDedicatedServerClientSide : public Client { public: void receive(char* b, int s) { ... } };   class NonDedicatedServer : public NonDedicatedServerServerSide, NonDedicatedServerClientSide { ... };

---

Citation:

---

en fait la fonction receive() est appellée depuis Server et Client, donc pour les cast c'est loupé

---

Justement, j'ai fait des casts pour appeler la fonction depuis Server et Client.

tu as compris le problème à l'envers... je veux deux comportements différents de receive() selon qu'il sagisse d'un client ou d'un server, et receive() est appellé DEPUIS les Server et Client, pas depuis l'éxterieur ni depuis les sous-classes (d'ailleurs je devrais sans doute la mettre protected et non public) ;)

Citation:

---

Envoyé par Nico65

vous vous doutez bien que je ne veux pas renommer mes methodes en receivedPacket_Server ou ajouter un argument ou je ne sais quoi de sémantiquement inacceptable...

---

Mais en catégorisant la fonction ca ne marche pas ?

Un truc genre:

Code:

---

1 2 3 4 5 6

class TestNonDedicatedServer : public Server, Client {   public void Server::receivedPacket(char* buffer, int size) {} public void Client::receivedPacket(char* buffer, int size) {} };

---

Désolé j'ai pas vérifié, mais c'était un truc du genre je crois bien.