Francesco S. Carta said:
Hi there,
after reading an article complaining that pointers to member functions
are misconceived in C++, and after reading a comment about them saying
that they happen to be a rarely necessary feature - if ever necessary at
all - I decided to investigate them to see how I could take advantage of
them, and I also decided to post this message to get the group's feedback.
While I certainly don't use pointers to member functions in a regular
basis, I have had situations where they have been quite useful.
For a relatively large project, which consisted of many command-line
utility programs, I needed an easy way of having a common command-line
parameter interpreter which supported parameters common to all the program,
and where it would be as easy as possible to add new parameters.
After many trial-and-error rounds, I ended up with a solution which,
I think, was the cleanest and easiest. If you wanted to add eg. two new
command-line parameters which modify the same variable, you would do it
something like this:
class MyCLI: public CommandLineInterpreter
{
bool someOption;
public:
MyCLI(): someOption(false)
{
addOption("-x",&MyCLI::xOption, "Description of -x");
addOption("-y",&MyCLI::yOption, "Description of -y");
}
bool xOption()
{
someOption = true;
return true;
}
bool yOption()
{
someOption = false;
return true;
}
};
int main(int argc, char* argv[])
{
MyCLI cli;
if(!cli.parse(argc, argv)) return 1;
...
}
The actual implementation of the CommandLineInterpreter::addOption()
function is a bit complicated because it has to be templatized, but its
usage is pretty simple, as demonstrated above. Without support for member
function pointers, it would be quite more complicated.
Naturally CommandLineInterpreter also provided utility functions for
the derived class to use (eg. to retrieve subsequent command-line
parameters, if it needed them, etc.)
