mlimber wrote:
[....]
Item# Object/Member
======================================
1. c1/a/arg1
2. c2/b/arg1, arg2, arg3
3. c3/c/arg1, arg2, arg3, arg4
So if 1 is selected, I invoke c1.a(arg1), 2 is selected, I invoke
c2.b(arg1, arg2), etc.
My thougths are to implement classes MenuItem0 .. MenuItem3 which work
with 0 .. 3 arguments to the function. I'm going around in circles
trying to implement this. Could use some assistance?
I suspect an alternative is to use function overloading.
Thanks
There's no inherent problem in implementing it this way. What is wrong
exactly? Can you post some code that demonstrates the problem?
Right!!.
Actually, the 'Loki' library would be ideal but what irritates the hell
out of me is I'm _no kidding_ stuck (just not willing right now to pay
the difference to upgade to GCC 3.3.2) with a compiler so old that's it
not worth the effort using these high end beasts of a library. At best
here's what I came up with.
class BaseMenuItem {
public:
virtual void invoke() const = 0;
};
template<class Class, class MemFuncPtr>
class MenuItem0: public BaseMenuItem {
private:
Class& object;
MemFuncPtr function;
public:
MenuItem0(Class& obj, MemFuncPtr mfp):
object(obj), function(mfp) {}
virtual void invoke() const { object.*function(); }
};
template<class Class, class MemFuncPtr, class Param1>
class MenuItem1: public BaseMenuItem {
private:
Class& object;
MemFuncPtr function;
Param1 parameter1;
public:
MenuItem1(Class& obj, MemFuncPtr mfp, Param1& p1):
object(obj), function(mfp), parameter1(p1) {}
virtual void invoke() const { object.*function(parameter1); }
};
template<class Class, class MemFuncPtr, class Param1, class Param2>
class MenuItem2: public BaseMenuItem {
private:
Class& object;
MemFuncPtr function;
Param1 parameter1;
Param2 parameter2;
public:
MenuItem2(Class& obj, MemFuncPtr mfp, Param1& p1, Param2 p2):
object(obj), function(mfp), parameter1(p1), parameter2(p2) {}
virtual void invoke() const { object.*function(parameter1,
parameter2); }
};
Thank goodness I dont have 50 of those :)
An alternative I think is to use function overloading.. so I'm
experimenting. In modern C++ design the Loki library has some fancy
way (the concept revolves around a factory) of allowing up to 50
arguments.
So I'm trying to see if function overloading will simplify that...