Trouble combining GP and OOP concepts - c++

Question

I have a class with a templated member function:
class Person
{
template <typename TItem>
void DoSomething(TItem item)
{
item.Action();
}
};
This allows me to pass any item with an Action member function, and the person will perform that action with the item. So I could do:
Person person;
BaseballBat bat;
person.DoSomething(bat);
This structure allows me to call functions with any type of object. However, if I want to store any type of object, I'd have to template the class:
template <TItem>
class Person
{
public:
void DoSomething()
{
this->Item.Action();
}
void SetItem(TItem item)
{
this->Item = item;
}
private:
TItem Item;
};
Person<BaseballBat> person;
BaseballBat bat;
person.SetItem(&bat);
person.DoSomething();
This is annoying because I'd have to re-instantiate the Person class to change the type of object.
Alternatively, I could derive the item from a parent class:
class Person
{
public:
void DoSomething()
{
this->Item.Action();
}
void SetItem(TItem* item)
{
this->Item = item;
}
private:
ParentItem* Item;
};
class ParentItem{};
class BaseballBat : public ParentItem
{}
Person person;
BaseballBat bat;
person.SetItem(&bat);
person.DoSomething();
This is annoying because I have to maintain the inheritance structure for all Items (which seems very "non-GP").
The problem really comes when I have multiple layers of "objects that contain objects" - that is, I'd have to "pass along" the function template arguments from a very "top level" call down to the contained classes:
class BaseballBat
{
void DoAction();
};
class Child
{
template <typename TItem>
void DoAction(TItem item)
{
item.DoAction();
}
};
class Person
{
Child child;
// This is annoying to have to pass the item to the person, who then has to pass it to the child. I'd rather "give" the child an Item, then just be able to call child.DoAction(), where the Person doesn't know anything about the item.
template <typename TItem>
void PlayWithChild(TItem item)
{
child.DoAction(item);
}
}
Can anyone comment about how to correctly mix these two ideas of function templates and storing objects as member data? (The above are just cheesy examples to try to demonstrate - if they don't make sense or you have better examples, I'm all ears :) ).
--------- Edit ---------
Maybe a better example is a simplification of my real case.
I have a class Matcher that has a member function:
template<typename TDistanceFunctor, typename TPropagationFunctor>
void Matcher::Compute(TDistanceFunctor distanceFunctor, TPropagationFunctor propagationFunctor);
Then I have another class, ImageAlgorithm, that uses a Matcher:
template<typename TMatcher>
void ImageAlgorithm::Compute(TMatcher matcher)
{
matcher.Compute(...); // How do I get the DistanceFunctor and the PropagationFunctor here?
}
I want to call these things like:
Matcher myMatcher;
.... Setup matcher (how?) ...
ImageAlgorithm algorithm;
algorithm.Compute(myMatcher);
I don't know how to "pass through" the DistanceFunctor and PropagationFunctor through the ImageAlgorithm object so it can get to the Matcher object inside of the ImageAlgorithm::Compute call. Of course I could template Matcher on TDistanceFunctor and store a TDistanceFunctor as a member variable, but then later I can't change the distance functor that the matcher uses to a different type of distance functor.

Answer 1

You can try using boost::any to hold your type-variant members.
From the overview:
The boost::any class (...) supports copying of any value type and safe checked extraction of that value strictly against its type.
EDIT
You're right that invocation of the stored functor with boost any would be problematic. So I suggest another solution:
Use std::function (or boost::function) to wrap your functors. That way Matcher can hold function objects of the relevant syntax (e.g. no parameters), and does not need to be templated over the functors types.
The function object already does the combination between OO (at least in some sense) and GP for you.