Polymorphic subtyping in C++ - c++

Question

I'm quite new to C++, and I need a clarify porting a project from Java.
In Java I can declare a base class and its derived, with generics, in this way:
public class GenericHost{
public enum HostType{
server,
client
}
public HostType type_;
}
public class MyClient extends GenericHost{
public String clientName;
}
public class MyServer extends GenericHost{
public String serverName;
}
public abstract class GenericNetwork<hostType extends GenericHost> {
public enum NetworkType{
central,
peripheral
}
private NetworkType type_;
protected hostType masterHost;
public hostType getMasterHost(){
return masterHost;
}
public abstract String getName();
}
public class CentralNetwork extends GenericNetwork<MyServer>{
#Override
public String getName(){
return masterHost.serverName;
}
}
public class PeripheralNetwork extends GenericNetwork<MyClient>{
#Override
public String getName(){
return masterHost.clientName;
}
}
This allows me to:
In derived classes I'm allowed to use methods and variables of specified derived class (e.g. serverName / clientName in CentralNetwork / PeripheralNetwork) and not only of the base class
Derived class is tiped, so the compiler / editor can suggest me every method & variable during code editing
I'm forced to use a class that is derived from the base class (GenericNetwork / GenericHost), every error is at compile time and not run time
Every method / variable that use generics will be treated in derived class as the child class and not the base class (e.g. in CentralNetwork, the getMasterHost will return the derived MyServer, not the base GenericHost).
I wish to know if does exist anything similar in C++.
I already looked for templates, inheritance and subtyping but I can't find a way to do something smarter like I did in Java. I hope I missed something...
EDIT:
This what I tried in C++:
class GenericHost{
public enum HostType{
server,
client
}
public HostType type_;
}
class MyClient : public GenericHost{
public String clientName;
}
class MyServer : public GenericHost{
public String serverName;
}
template<class hostType : GenericHost> <--WISH, forced base class
class GenericNetwork {
public enum NetworkType{
central,
peripheral
}
private NetworkType type_;
protected hostType masterHost;
public hostType getMasterHost(){
return masterHost; <--WISH, should return MyServer / Myclient in derived class
}
public virtual std::string getName();
}
class CentralNetwork<MyServer> : public GenericNetwork{
public std::string getName(){
return masterHost.serverName; <--WISH, tiped and suggested by editor / compiler
}
}
class PeripheralNetwork<MyClient>: public GenericNetwork{
public std::string getName(){
return masterHost.clientName; <--WISH, tiped and suggested by editor / compiler
}
}
I don't have the C project with me now, so I rewrote it on the fly, sorry for any mistake...

Answer 1

As far as I know there's no explicit feature that lets you do this. You can use static_cast though, which will give you a compile time error if the types are not compatible.
template <class hostType>
class GenericNetwork {
public:
GenericNetwork() {
static_cast<GenericHost*>((hostType*)nullptr); // or 0 or NULL if not C++11
}
};
If hostType and GenericHost are compatible, the cast will succeed but do nothing. Otherwise, you'll get a compile time error.

Answer 2

There's no dedicated feature to explicitly constrain template arguments (*), but you can use (C++11's)
static_assert( std::is_base_of<GenericHost, hostType>::value,
"The template argument must be derived from GenericHost" );
(*) There'll be template constraints hopefully in C++17.
This is a compile-time assertion and can be used as a declaration:
template<class hostType>
class GenericNetwork {
static_assert( std::is_base_of<GenericHost, hostType>::value,
"The template argument must be derived from GenericHost" );
public:
enum NetworkType{
central,
peripheral
}
virtual ~GenericNetwork(); // you typically want a virtual dtor in an ABC
hostType& getMasterHost(){ // you might want to return a (const) reference
return masterHost;
}
virtual std::string getName() = 0; // abstract
private:
NetworkType type_;
hostType masterHost; // or protected
// consider making the copy ctor and copy assignment op protected
// to prevent unintended slicing
}

Answer 3

As everybody points out, C++ templates can implement this so it doesn't merit dedicated syntax.
Here's a rather literal translation that enforces the baseclass requirement by simply doing it.
#include <string>
struct GenericHost {
enum HostType { server,client } type_;
};
template<class GenericHost=GenericHost>
struct MyClient : GenericHost { std::string clientName; };
template<class GenericHost=GenericHost>
struct MyServer : GenericHost { std::string serverName; };
template< template<class> class SpecificHost, class GenericHost=GenericHost >
struct GenericNetwork
{
typedef SpecificHost<GenericHost> hostType;
virtual ~GenericNetwork() { };
enum NetworkType { central, peripheral };
hostType getMasterHost() { return masterHost; }
virtual std::string getName() = 0;
protected: hostType masterHost;
private: NetworkType type_;
};
struct CentralNetwork : GenericNetwork<MyServer> {
std::string getName() { return masterHost.serverName; }
};
struct PeripheralNetwork : GenericNetwork<MyClient> {
std::string getName() { return masterHost.clientName; }
};
// testing: force instantiation:
struct CentralNetwork makeme;
struct PeripheralNetwork metoo;
std::string doit() { return makeme.getName() + metoo.getName(); }
I believe this gets all four desiderata, though the errors would be detected in different places. As others point out static_cast<requiredBase*>((testedClass*)0); can do that job, but bypassing the protection takes work, not just a mistake, and it would show up in the type system so I don't see the point.
(edit: add the virtual destructor, no dessert for me tonight. Bad dog.)