C++ Instantiate subclass from multiple choices - c++

Question

I'm using a library that implements different types of network protocols like in the following simplified example that hopefully illustrates the problem I have. NOTE: This is all pseudo code just to show the overall problem.
class Network
{
virtual void connect() {...}
void readPacket() = 0;
};
class NetworkClient : public Network
{
virtual void connect(int ip, int port) {super::connect() ...}
};
class NetworkServer : public Network
{
virtual void connect(int port) {super::connect() ...}
};
class ProtocolAClient : public NetworkClient
{
void readPacket() {...}
};
class ProtocolAServer : public NetworkServer
{
void readPacket() {...}
};
class ProtocolBClient : public NetworkClient
{
void readPacket() {...}
};
class ProtocolBServer : public NetworkServer
{
void readPacket() {...}
};
Now in my application, I want to have a Client and a Server, which should be either a ProtocolA or ProtocolB client/server, depending on which protocol the user chooses to connect with.
So I thought I could create my application classes like this.
class AppClient : public NetworkClient
{
... custom functionality needed by the app client ...
void sendAppData(...)
};
class AppServer : public NetworkServer
{
... custom functionality needed by the app server ...
void sendAppData(...)
};
Then I thought that when I need a client, for example, in the application I could just do this.
AppClient *client;
if(useProtocalA)
client = new ProtocolAClient;
else
client = new ProtocolBClient;
client->sendAppData();
However the compiler quickly let me know that this is not possible since ProtocolAClient and ProtocolBClient are not an AppClient. Here is the exact compiler error.
error C2440: '=' : cannot convert from 'ProtocolAClient *' to 'AppClient *'
So my next idea was to make AppClient and AppServer template classes, but that doesn't work either as you can't get a pointer to the instance as the pointer doesn't have a template argument like this.
AppClient *client; <--- Uh oh... missing template argument!
if(useProtocalA)
client = new AppClient<ProtocolAClient>;
else
client = new AppClient<ProtocolBClient>;
client->sendAppData();
This seems like it should be such a simple problem to solve, but I just can't seem to see the solution.

Answer 1

So you have the following classes:
class Network
{
virtual void connect() {...}
void readPacket() = 0;
}
class NetworkClient : public Network
{
virtual void connect(int ip, int port) {super::connect() ...}
}
class AppClient : public NetworkClient
{
... custom functionality needed by the app client ...
void sendAppData(...)
}
class ProtocolAClient : public NetworkClient
{
void readPacket() {...}
}
class ProtocolBClient : public NetworkClient
{
void readPacket() {...}
}
The problem is that you want an AppClient object, but the ProtocolAClient is of type NetworkClient and not type AppClient.
Your inheritance looks like this:
Network ---- NetworkClient ---- ProtocolAClient
|---- ProtocolBClient
|---- AppClient
As you can see, neither ProtocolAClient nor ProtocolBClient is of type AppClient, but all of them are of type NetworkClient.
So, if you want this code to work:
AppClient *client;
if(useProtocalA)
client = new ProtocolAClient;
else
client = new ProtocolBClient;
client->sendAppData();
you will have to do the one of the following changes:
A) change your ProtocolAClient and ProtocolBClient to inherit the AppClient class:
class ProtocolAClient : public AppClient
{
void readPacket() {...}
}
class ProtocolBClient : public AppClient
{
void readPacket() {...}
}
Now your inheritance looks like this:
Network ---- NetworkClient ---- AppClient ---- ProtocolAClient
|---- ProtocolBClient
or B) - Recommended: don't use AppClient as you already have NetworkClient:
NetworkClient*client;
if(useProtocalA)
client = new ProtocolAClient;
else
client = new ProtocolBClient;
client->sendAppData();

Answer 2

I think I'd stop right at:
class Network {};
class NetworkClient : public Network {};
class NetworkServer : public Network {};
At first glance, this already looks like a serious problem. Public inheritance implies the Liskov Substitution Principle--you should be able to substitute an instance of the derived class anywhere an instance of the base class is needed.
A NetworkClient (or a NetworkServer) is not a network, and I doubt there's even one circumstance in which either can be substituted for a network (not to mention all possible circumstances). As such, it seems to me that your basic design is problematic from the beginning.
My immediate reaction would be that you probably want something like:
class ProtocolA {};
class ProtocolB {};
template <class Protocol>
class Client {};
template <class Protocol>
class Server {};
With this, you can fairly easily instantiate a client or server using either protocol. This does not, however, support run-time substitution. That is to say, you don't get anything like a base class that lets you deal completely transparently (at runtime) with an object that may be any of two or more different types.
If you really need that, you probably want something more like:
class Protocol {};
class ProtocolA : public Protocol {};
class ProtocolB : public Protocol {};
class Client {
Protocol *p;
public:
Client(Protocol *p) : p(p) {}
};
class Server {
Protocol *p;
public:
Server(Protocol *p) : p(p) {}
};
[aside: despite following the syntax reasonably closely, this is really pseudo-code not C++. You clearly need to add a number of other things like virtual destructors before the code can actually be used at all.]
Then you instantiate an instance of the correct Protocol, and pass (a pointer to) that instance to create a Client or Server object.
With either of these, the Client/Server uses the Protocol to do communication, but (unlike with public inheritance) we have not made nonsensical assertions about being able to substitute a Client/Server for a network (or network protocol).

Answer 3

For me, your class hierarchy isn't precisely defined. In particular: what exactly is the NetworkClient class and what are you going to use it for? If this is to be used so that client->sendAppData() has to be called, then ProtocolAClient class should not derive from it. This solution you gave seems the best:
AppClient *client; <--- Uh oh... missing template argument!
if(useProtocalA)
client = new AppClient<ProtocolAClient>;
else
client = new AppClient<ProtocolBClient>;
client->sendAppData();
But you say you lack the ability to have this AppClient without specifying the protocol client class.
You can solve this problem by using virtual-template-pair idiom (or whatever name is used for it):
class AppClient { /* ... */ virtual void sendAppData() = 0; };
template <class ProtocolClientClass>
class AppClientSpec: public AppClient
{
/* ... */
ProtocolClientClass* inproto; // or whatever...
virtual void sendAppData() { return inproto->sendAppData(); }
};
And now your example can be fixed as:
AppClient *client; <--- Uh oh... missing template argument!
if(useProtocalA)
client = new AppClientSpec<ProtocolAClient>;
else
client = new AppClientSpec<ProtocolBClient>;
client->sendAppData();