Discussion :

[Nico65]

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 :

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

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 :

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

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

[loufoque]

Voir l'héritage virtuel.

[JolyLoic]

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).

[Nico65]

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 :

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

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

[loufoque]

En fait ça marche très bien.

Code :

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

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.

[JolyLoic]

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.

[Nico65]

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 :

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

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 {
   ...
};

[nicroman]

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 :

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

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.