Re: Alternative to virtual template function
jacob.h.page@gmail.com wrote:
I've recently begun a project in C++ after being immersed in C# for a
long time, and now I'm stumped on a problem I'm trying to solve. My
main issue is that I'm trying to use templates in the same fashion that
I'd be using generics in C# or Java. Here's what I'm attempting:
Because my program is going to be cross-platform, I'm writing an
Application class that interfaces with an abstract IPlatform object
pointer (a facade). My intent is to keep the Application class code
the same among all the platforms and write multiple concrete classes
within each platform-specific project that implement the facade's
interface. Things were going smoothly using this approach until I came
across the need for generics.
Since some of my target platforms don't provide an STL implementation,
I decided to create interfaces mimicking nice modern container classes
as well as factory methods in IPlatform that create the objects.
Err, I'd rather fix said platforms so they do provide a more complete C++
standardlibrary. There are several standardlibrary implementations
available that you could either port yourself or have ported. I'm
particularly thinking of STLport (free) and Dinkumware (commercial) here,
but even the original STL would be a choice since it only provides
containers, iterators and algorithms and not the whole stdlib including
IOStreams, locales, complex numbers, etc.
Anyhow, the reason that virtual and template don't mix is that one decides
the actual function to call on compile time, the other at runtime. Also, a
template only results in code when it is used, otherwise not. That means
that if you don't use a foo<X> there is no code generated which you could
call at runtime.
For example (pardon my simplified examples):
template<class T> class IList
{
public:
virtual int getCount() = 0;
// etc
}
class IPlatform
{
public:
template<class T> virtual IList<T>* createList() = 0;
// etc
};
This just screams overhead&complication at me. What you can do is provide a
list-type that stores objects in a typeless manner (I think the way that
Java does it is to create lists of class Object, which is basically the
same) and then check the type at runtime, which is ugly compared to the
type-safety of C++'s containers. Also, it is not a trivial task to get
right and with a pleasant interface.
However, this is not allowed, since template members cannot be virtual!
And they can't be. The point is that only the final client knows for which T
createList() would have to be instantiated. Further, the concrete IPlatform
implementation needs to provide all createList() implementations for the
interface of the baseclass. It can't do that because when it is compiled it
is far from clear which of these are required.
The only way out is to provide the implementation to the clients of class
IPlatform. However, this implementation needs to be platform specific so
you can ditch the whole runtime-indirection via IPlatform in favour of
compile-time indirection via preprocessor.
You can't have the cake and eat it, you need to evaluate which one you need,
runtime or compile time dispatch, runtime or compile time type checking.
Uli
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]