Re: Alternative to virtual template function
jacob.h.page@gmail.com ha scritto:
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.
The use of the facade pattern is a good thing to achieve cross-platform.
Implementing the pattern through polymorphism is a typical way to go,
especially in some languages, but, I know I will be heavily criticized
for what I'm going to say, it's not always the best way to go in C++,
IMHO. Polymorphism is good if you want to select among different
implementations of the facade *at runtime*, but the platform is going to
be chosen at compile time! Consider the two approaches:
--- facade.h
struct IPlatform
{
virtual void foo() = 0;
// etc.
};
--- facadeImplPC.cpp
struct IPlatformPC : IPlatform
{
void foo() { /* PC implementation here */ }
// etc.
};
--- facadeImplMac.cpp
struct IPlatformMac : IPlatform
{
void foo() { /* Mac implementation here */ }
// etc.
};
---
and the "legacy" approach:
--- facade.h
namespace Platform
{
void foo();
// etc.
}
--- facadeImplPC.cpp
namespace Platform
{
void foo() { /* PC implementation here */ }
// etc.
}
--- facadeImplMac.cpp
namespace Platform
{
void foo() { /* Mac implementation here */ }
// etc.
}
---
Is there a real disadvantage with the latter? I don't think so. Notice
that the latter approach does not involve virtual functions and pest
singleton objects, so it can actually be easier to develop and maintain.
I'm not saying with this that you can or should always avoid
polymorphism, but for the special case of platform-abstraction, there's
little or no advantages and quite a few disadvantages in using it.
About platform-dependent templates, unless you have a cross-compiler
that support export, you must put the definition in a header file, but
even that is easily achievable:
--- platformTemplates.h
namespace Platform
{
// forward declaration of templates
}
#if defined(PC)
#include "platformTemplatesPC.h"
#elif defined(MAC)
#include "platformTemplatesMac.h"
#else
#error Platform unknown
#endif
---
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. For
example (pardon my simplified examples):
template<class T> class IList
{
public:
virtual int getCount() = 0;
// etc
}
Even in this case, I dispute the use of polymorphim. How many
implementations of a list you are going to get on a specific platform?
Just one. With a clever use of typedefs and wrappers you can totally
avoid polymorphism and you'll get the most out of templates.
class IPlatform
{
public:
template<class T> virtual IList<T>* createList() = 0;
// etc
};
However, this is not allowed, since template members cannot be virtual!
So I ditched the member function idea and went the route of
regular-old functions instead:
In a platform-independent header:
template<class T> IList<T>* createList();
In a platform-specific header:
template<class T> StlListAdapter : public IList<T>
{
public:
// blah, blah
};
// Placed in a header, since you apparently can't put
// implementation in a CPP file >:(
template<class T> IList<T>* createList()
{
return new StlListAdapter<T>();
}
Yes, something like that. Regular-old functions are still useful! You
don't need to use a new idiom just because it's new. However, you should
go a step further and ditch even the IList<> abstract base, IMHO.
Unfortunately, this is causing me linking errors when I try to call the
function defined in the platform-independent header. Argh! So now I'm
left with the sinking feeling that I'm trying to do something that
really cannot be done very elegantly using C++.
You are not showing your linking errors, so I can't help you with that.
Am I making some coding mistakes, or is this really something that C++
is not good at? Do any of you have an alternative approach that you
would take to solve this problem?
Avoid virtual polymorphism when it's not really necessary, as in this
case. In cases you need polymorphism, consider also static polymorphism
(i.e.: polymorphism achieved through templates instead of virtual
functions) which is sometimes a viable and more powerful alternative.
Regards,
Ganesh
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]