One method for doing the same with different variables - c++

Question

i have something like that
class Foo {
Bar a, b, c;
void doStuffWithA();
void doStuffWithB();
void doStuffWithC();
}
instead of writing an implementation for each of the methods i want something like a template. How to do that?
Cheers,
Dirk
Edit:
I explicitly need to know which variable I do stuff with (recursion):
class Foo {
Bar a, b, c;
Foo* parent;
static void doRecursiveStuffWithA(Foo *_node) {
if(_node->parent==NULL) {
return;
} else {
doRecursiveStuffWithA(_node->parent)
}
}
static void doRecursiveStuffWithB(Foo *_node) {
if(_node->parent==NULL) {
return;
} else {
doRecursiveStuffWithB(_node->parent)
}
}
static void doRecursiveStuffWithC(Foo *_node) {
if(_node->parent==NULL) {
return;
} else {
doRecursiveStuffWithC(_node->parent)
}
}
}
Edit2:
Maybe that does explain better what my problem is:
class Foo {
public:
int a, b, c;
}
class Bar {
public:
void doStuffWithAOfFoo(Foo *_foo);
void doStuffWithBOfFoo(Foo *_foo);
void doStuffWithCOfFoo(Foo *_foo);
}
I just want to keep my code simple and not to have to implement doStuffWithX three times...

Answer 1

I think you want parameters...
class Foo {
Bar a, b, c;
void doStuffWithBar(Bar x);
}
Templates are for dealing with a variety of data-types and function arguments are for dealing with a variety of variables.

Answer 2

#Andrew White has the simplest answer. If you want a function that can do the same thing but with a variety of different values, it should take an argument.
There are cases where we legitimately want different methods that look almost identical, like getFirstName(), setFirstName(), getLastName(), setLastName(). There, using arguments would rather defeat the purpose.
The architecture there is perfectly sound (and indeed widely accepted); the only problem is the tedium of typing it all up. If you just want to avoid all the extra typing, consider using an Integrated Development Environment that offers "code templates". Both Eclipse and Visual Studio (among many others, surely) will let you select a variable and click a button to generate a getter and setter for that variable. All the code with none of the hassle.

Answer 3

You can use a reference:
class Foo {
Bar a, b, c;
void doStuffWithBar(Bar& what)
{
print(what);
bool flag = check(what);
if (!flag)
doStuffWithBar(what);
}
}
You can use a pointer to member:
class Foo {
Bar a, b, c;
typedef Bar (Foo::*PointerToBar);
void doStuffWithBar(PointerToBar selector)
{
print(this->*selector);
bool flag = check(this->*selector);
if (!flag)
doStuffWithBar(selector);
}
}
The latter solution is more flexible: you can choose another object and/or another member with which to continue recursion (pointers to members are obscure and are rarely used; don't use them unless you need this flexibility):
class Foo {
Bar a, b, c;
Foo* next;
typedef Bar (Foo::*PointerToBar);
void doStuffWithBar(PointerToBar selector)
{
print(this->*selector);
if (next)
next->doStuffWithBar(selector);
}
}

Answer 4

Code smell - design problem? The repetition here makes it feels like Bar needs a new method:
void Bar::doStuff(Foo &foo);
Then you need to figure out what is public, private and const.
Edit: Your edit changes things a little. I now really feel that there are ways your design could be improved, e.g. STL container and algorithms.

Answer 5

To expand a little on Andrew's solutions, you might also be looking for:
void doStuffWithBar(Bar x, Bar y, Bar z);
If you actually have BarX x, BarY y and BarZ z, then you probably want to overload your member function in your class
class Foo {
BarX x;
BarY y;
BarZ z;
void doStuffWithBar(BarX x);
void doStuffWithBar(BarY y);
void doStuffWithBar(BarZ z);
};
You might also be looking for something like (this is the ugliest solution and I wouldn't really recommend it):
void doStuffWithBar(int n)
{
if(n==0)
doSomethingWithX();
else if(n==1)
doSomethingWithY();
else if(n==2)
doSomethingWithZ();
}
Edit:
ReturnType Bar::doStuffWithBar(ParamA a, ParamB b);