Re: templates of derived classes
Alf P. Steinbach wrote:
You can templatize the functions, or make the arguments polymorphic, or
duplicate the functions.
I don't want to templatize them, nor to duplicate them, because the
behaviour don't change with the different classes. Make the argument
polimorphic: yes, but how?
I would like to avoid the pointer in T
You have not shown a "pointer in T".
I've shown it just after that sentence...
, otherwise a possible solution would be:
template <typename T>
class Foo
{
public:
template <typename IteratorT>
static Foo<T>* GenerateFrom(IteratorT begin, IteratorT end);
// impl.
protected:
T* obj_;
}
Missing semicolon: copy and paste code, please.
Well, the real code is quite more complex and structured than this one.
I can't post the real code, but let me try something that should be
similar with a little bit of context, in the following: maybe it's a
little bit clearer.
This particular problem seems to be: you want a factory in a class C to
produce a pointer to an object of class derived from C.
Try out this problem without templates first.
The templates are the problem, if I remove them, I can't have the same
structure.
It's unclear what the problems are. Possibly some will post a technical
solution to something that might be one of the problems. You have mixed
(1) templates, (2) factories and (3) polymorphism to achieve
/something/, but you have neglected to tell those who might help what
that something is, which is what you should do: explain what you're
trying to achieve, not what you think might be relevant to achieving it.
Ok, let's try that way, I'll explain directly my problem in the context.
I have a tree. This tree is not a class, it's just a collection of tree
nodes. The tree nodes are templatized. So, basically:
class TreeNodeBase;
typedef boost::shared_ptr<TreeNodeBase> TreeNodePtr;
class TreeNodeBase
{
// impl.
};
template <class Item>
class TreeNode
: public TreeNodeBase
{
public:
TreeNode(const Item& item)
: TreeNodeBase()
, item_(item)
{
}
const Item& GetItem() const { return item_; }
Item& GetItemRef() { return item_; } // safer - explicit call
TreeNode<Item>* FindNode(const Item& item);
const TreeNode<Item>* FindNode(const Item& item) const;
template <class ItemIt, class ItemDistance>
static TreeNodePtr GenerateMinimumSpanningTree(ItemIt begin, ItemIt end);
private:
Item item_;
};
Ok? I can generate a minimum spanning tree from a set of elements by
GenerateMinimumSpanningTree, giving some forward iterators, and
specifying the distance class that i want to use to perform the weight
calculation.
In order to generate the MinimumSanningTree, the
GenerateMinimumSpanningTree function will use the Tree constructor, in a
piece of code like:
std::vector<std::pair<TreeNodePtr, ItemIt> > trees;
for(ItemIt item = begin; item != end; ++item)
trees.push_back(std::make_pair(TreeNodePtr(new TreeNode<Item>(*item)),
item));
(the vector is used in the algorithm for the minimum spanning tree).
Then, after I generate like this a tree, in a particular problem I need
a tree of Descriptors.
Once I generate this tree of descriptors passing the appropriate forward
iterators to the GenerateMinimumSpannigTree algorithm, I can give it to
a class that will perform some classification of this tree. Ok? This
class will pass the tree to other members that have to perform some
calculation to perform the classification, that is, the tree will be
read by some functions, for example:
class FactorGraphSolver
{
public:
void SolveFor(QMUL::TreeNode<Descriptor>* node, unsigned categoryID,
unsigned partsLabelNumber);
// other things...
};
And I'm really fine with that function signature, because actually the
FactorGraphSolver needs just a Tree of Descriptors, nothing more,
nothing less.
Ok? Let's say that now I want to add a particular additional information
to that tree node, for example a reference to the real descriptor that
generated it, and a label. Then I'll pass to the classification class,
and this class will call the same usual subclasses to perform the
calculations and, once done, will label every node properly. At the end
of the function, I could explore the tree and, being composed of
descriptor that have a reference of the elements that have generated
them, I can label the original elements.
Ok, the problem is this one. It seems to me that I've said enough to
understand it. I won't post the real code because it's long and mostly
unrelated to the problem.
Thank you!
Zeppe