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.
In which case, you're probably doing it wrong. C++ is grouned
in value semantics, Java (and I assume C#, although I've never
used it) in reference semantics. This difference has a very
distinct influence on the way you define and use containers (and
I suppose that's what's interesting you, since that's about all
Java generics are good for).
C++ is a multi-paradigm language, and you can use it to emulate
Java. If you do so for the occasional case where the Java
solution is the most appropriate, that's fine; that's what
multi-paradigmism is about. If you try to use it everywhere
like Java, why bother?
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,
Which ones are those? I don't know of any modern C++ compiler
which doesn't support the standard library.
I decided to create interfaces mimicking nice modern container
classes as well as factory methods in IPlatform that create
the objects.
This seems all wrong for C++. C++ uses value semantics, and in
my experience, it is very, very rare to allocate a container
dynamically.
It even seems a bit wrong for Java; the Java Container classes
don't have any factory methods. On the other hand, I've seen
factories and interfaces used to emulate the compilation
firewall idiom or to compensate for the fact that in Java, you
cannot separate the interface from the implementation in a
single class. But C++ doesn't have that defect, and so you
don't need the work around.
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
};
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>();
}
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++.
Well, what you are trying to do is the problem. C++ can be used
to generate excess noise and complexity, but the ways it uses to
do so are different from the ways Java does it. If the goal is
just excess complexity, say so, and I'm sure we can come up with
hundreds, if not thousands of solutions:-).
Seriously, what are you trying to accomplish? Even in Java,
such techniques are only used in special cases. If you're
trying to work around the problem that you have to provide the
implementation of the class in the same file as the definition
of its interface, then the answer is simple: C++ doesn't have
this problem. (I'm not saying that the solution it has is a
good one---textual inclusion, yuck. But at least it exists, and
sort of works, with a little bit of programmer discipline. And
if you avoid templates, or only use compilers which support
export.) If you have some other problem you are trying to
solve, explain what it is, and we will see what kind of a
solution we can come up with in idiomatic C++.
Am I making some coding mistakes, or is this really something
that C++ is not good at?
"This" being obfuscation, I'd say that it is something that C++
excels at, but you're going about it the wrong way. There are
lot simpler ways of making code unreadable in C++. :-)
Do any of you have an alternative approach that you would take
to solve this problem?
Not until I know what the problem is.
--
James Kanze GABI Software
Conseils en informatique orient?e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S?mard, 78210 St.-Cyr-l'?cole, France, +33 (0)1 30 23 00 34
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]