Re: templated virtual functions??
On Apr 9, 2:53 am, jor...@hotmail.com wrote:
Let say that I wanted to do a filesystem browser. The filesystem is a
tree structure, so my idea was to make an general tree browser that
could browse anything that implemented the ITreeStructure interface.
Now I want to make a generic container class that is a tree and can
hold any data type.
The declarations for this look like this:
template<typename T>
class Tree : public ITreeStructure
{
typedef unsigned int size_type;
typedef std::vector<Tree>::iterator iterator;
typedef const std::vector<Tree>::iterator const_iterator;
bool is_leaf() = 0;
ITreeStructure& parent() = 0;
iterator children_begin() = 0;
iterator children_end() = 0;
T get_value(void) = 0;
};
class TreeBrowser : public IWindowControl
{
public:
TreeBrowser();
TreeBrowser(ITreeStructure& tree);
void BrowseTree(ITreeStructure& tree);
private:
ITreeStructure* m_treep;
};
Now the question is how to define the ITreeStructure interface?
I would like to define it like this
class ITreeStructure
{
public:
virtual bool is_leaf() = 0;
virtual ITreeStructure& parent() = 0;
virtual std::vector<ITreeStructure>::iterator children_begin() = 0;
virtual std::vector<ITreeStructure>::iterator children_end() = 0;
template<typename T> virtual T get_value(void) = 0;
};
The problem is the get_value method since templated virtual functions
are not allowed.
...
2. Is there an reasonably simple way around this? Or can I change my
design some way and have both decoupling and still be able to have an
parameterized implementation of a tree structure?
As declared (assuming your interface would be valid C++), it implies
that I can use an arbitrary T in get_value and expect it to work. I.e.
I can do get_value<int> on some node, then get_value<float> on the
same node, etc. This is probably not what you have in mind here, since
your implementation class restricts get_value for a particular T for
the entire tree.
Now then, how would you use the interface you've written? Let's say
you have a function that takes an argument of type ITreeStructure*;
now what? You don't know what T you can give to get_value so that it
actually works. You could take it as a template parameter, of course,
but then you could just as well ask for ITreeStructure<T>*. The only
point in having your generic interface is to use methods other than
get_value - i.e., as long as you only want to traverse the tree, but
not retrieve the values, the interface is the same regardless of type
of values.
Therefore, the answer is: split your interface into two: a base
ITreeStructureBase, non-template, which contains all functions except
for get_value; and a template ITreeStructure<T>, deriving from
ITreeStructureBase, and containing virtual get_value<T>.
So my questions are:
1. Why isn't templated virtual functions allowed in C++?
Because that would require the ability to instantiate templates at run-
time, which effectively amounts to linking a full-featured C++
compiler into every program, and embedding the source code from the
definition context of your virtual templates (and all known
specializations thereof) in the executable. It is technically doable,
but very complicated in practice, would result in high size and
performance costs, and is certainly not worth the effort.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]