For a recent project of mine, I wanted to use what some people call "Compile Time Polymorphism" in C++. Here's how I implemented it.
Polymorphism in the context of programming computers usually refers to the ability to tread objects of a different data type through the same interface. In C++, this is often implemented through class inheritance and the use of virtual functions. The text book example of this concept is two classes,
Cat and
Dog, that inherit from a common super class
Animal.
Animal has a method
makeSound() that is implemented by each subclass accordingly. In real software projects, polymorphism is used to hide multiple implementations behind a uniform interface. Here's an example of how this concept is usually used in C++.
class Animal {
public:
void makeSound(void) = 0;
};
class Cat : public Animal {
public:
void makeSound(void);
};
class Dog : public Animal {
public:
void makeSound(void);
};
The issue with this code is that it requires the use of virtual functions which means you need a
vtable for the concrete subclasses. Usually, as a programmer, you don't need to worry about
vtables as the compiler takes care of that for you. But let's take a look at how this works anyways. A
vtable is basically a table of function pointers. For each of the concrete
classes shown above, the
vtable contains a pointer to the respective
makeSound method. Also, each
object carries a pointer to the
vtable. At runtime, when a virtual method of an object is called, the pointer to the
vtable is resolved to the actual
vtable. From there, the address of the method is loaded and the call to it is made indirectly. So the use of virtual methods not only increases the size of your code, but also the size of your objects. In addition to that, it forces the compiler to use indirect function calls through pointers which are usually slower than direct function calls. Again, the compiler takes care of all of that, so this is purely informational.
All of the above is okay and in fact required if you don't know the concrete type of an object until the software actually runs. Also, in most software projects, the drawbacks don't matter and aren't even noticeable. But there are situations where you may not want to pay the price of virtual methods, e.g. in a resource limited embedded system.
Also, there are situations where it is known at
compile time what the concrete implementation of an interface will be. This is true for example when you have an abstraction of an interface that is specific to a certain operating system: When you compile the software, you already know what the target operating system will be, so you can simply use and link to the right implementation of the interface, instead of post-poning the decision to runtime.
So how would you use polymorphism in C++ without the use of virtual methods?
Here's how you could do it:
typedef enum OperatingSystemImpl {
Darwin,
FreeBSD,
Linux
} OperatingSystemImpl_t;
template struct OperatingSystemChoice;
class DarwinImpl;
class FreeBSDImpl;
class LinuxImpl;
template<> struct OperatingSystemChoice {
typedef DarwinImpl m_type;
};
template<> struct OperatingSystemChoice {
typedef FreeBSDImpl m_type;
};
template<> struct OperatingSystemChoice {
typedef LinuxImpl m_type;
};
struct OperatingSystemService {
typedef OperatingSystemChoice< ... >::m_type m_type;
};
Of course, the ellipsis must be expanded, but more on that later. What's important is how software using this construct would use the code:
OperatingSystemService::m_type OsServiceObj;
The snipped above would create an object of the correct type, dependend on what the ellipsis expands to. The neat thing is that the template compiler ensures that the ellipsis is expanded to a valid "type" as defined in
enum OperatingSystemImpl. Also, it is made sure that the actual, underlying class is declared, e.g.
class DarwinImpl.
In other words: If you tried to
compile the software with the ellipsis expanded to
Windows, you'd get a compilation error. If you had implemented this using classic polymorphism, you'd probably have some code that dynamically created the right object depending on what input is given. That means, you have to test your compiled code, feeding it an invalid type. This mean you must
run your software. I'm convinced that finding problems earlier is better, so finding an issue when code is compiled is better than finding issues when code is run.
So back to how the ellipsis is expanded. Here's how CMake, a build system, comes into play. CMake uses input files that describe how the software needs to be compiled. Those input files, as with other build systems, are able to define compiler flags. Also, CMake defines a variable that contains the operating system's name. I suspect it's the output of
uname. So here's what I added to my top level
CMakeList.txt file:
add_definitions("-DOPERATING_SYSTEM=${CMAKE_SYSTEM_NAME}")
This makes the
OPERATING_SYSTEM macro known to the pre-processor. So the code with the ellipsis can be re-written like this:
struct OperatingSystemService {
typedef OperatingSystemChoice::m_type m_type;
};
Et voilà, the right type is picked when the code is compiled.
Here are the nice things about this: There is no need for virtual methods, eliminating the need for
vtables. Also, invalid or unsupported operating system types will be found at compile time vs. at runtime while the code for all supported operating systems will still be always compiled (just not used).
One downside may seem that you no longer have an enforced interface like when using purely virtual classes, i.e. the compiler may not tell you that you forgot to implement a newly added method to one of your implementation classes. However, this is more of a minor issue: You will still get a compilation error in that case, but only if you're compiling for the target system where you forgot to implement the newly added method.
