I've just got confused how to implement
something in a generic way in C++. It's a bit convoluted, so let me explain step by step.
Consider such code:
void a(int) {
// do
something
}
void b(int) {
//
something else
}
void function1() {
a(123);
a(456);
}
void function2() {
b(123);
b(456);
}
void test() {
function1();
function2();
}
It's easily noticable that function1 and function2 do
the same, with
the only different part being
the internal function.
Therefore, I want to make function generic to avoid code redundancy. I can do it using function pointers or templates. Let me choose
the latter
for now. My thinking is that it's better since
the compiler will surely be able to inline
the functions - am I correct? Can compilers still inline
the calls if they are made via function pointers? This is a side-question.
OK, back to
the original point... A solution with templates:
void a(int) {
// do
something
}
void b(int) {
//
something else
}
template<void (*param)(int) >
void function() {
param(123);
param(456);
}
void test() {
function<a>();
function<b>();
}
All OK. But I'm running into a problem: Can I still do that if a and b are generics themselves?
template<typename T>
void a(T t) {
// do
something
}
template<typename T>
void b(T t) {
//
something else
}
template< ...param... > // ???
void function() {
param<SomeType>(someobj);
param<AnotherType>(someotherobj);
}
void test() {
function<a>();
function<b>();
}
I know that a template parameter can be one of:
a type,
a template type,
a value of a type.
None of those seems to cover my situation. My main question is hence: How do I solve that, i.e. define function() in
the last example?
(Yes, function pointers seem to be a workaround in this exact case - provided they can also be inlined - but I'm looking
for a general solution
for this class of problems).
