Using function pointer forward declaration as lamba declaration - c++

Question

What's the closest I can get to something like this?
.h:
typedef bool (*DoWorkFunc)(uint32_t dParam1, uint32_t dParam2, bool bParam, float fParam1, float fParam2, MyClass& c1, MyClass2& c2);
void DoWork(DoWorkFunc func);
.cpp:
bool MyClass::MyFunc(uint32_t val) {
DoWork(DoWorkFunc { return c2.mVal < c1.mVal + fParam1 + fParam2; } );
auto f1 = DoWorkFunc { return (bParam ? dParam1 : c1.mVal) < mVal; };
auto f2 = DoWorkFunc { return ((dParam1 & dParam2) == 0) == bParam; };
auto f = val < 3 ? f1: f2;
DoWork(f);
}
This is the closest clean solution I've been able to get, which requires a mostly copy-pasted solution for the lambda forward declaration.
.h:
typedef bool (*DoWorkFunc)(uint32_t dParam1, uint32_t dParam2, bool bParam, float fParam1, float fParam2, MyClass& c1, MyClass2& c2);
#define DoWorkLambda [](uint32_t dParam1, uint32_t dParam2, bool bParam, float fParam1, float fParam2, MyClass& c1, MyClass2& c2) -> bool
void DoWork(DoWorkFunc func);
.cpp:
bool MyClass::MyFunc(uint32_t val) {
DoWork(DoWorkLambda { return c2.mVal < c1.mVal + fParam1 + fParam2; } );
auto f1 = DoWorkLambda { return (bParam ? dParam1 : c1.mVal) < mVal; };
auto f2 = DoWorkLambda { return ((dParam1 & dParam2) == 0) == bParam; };
auto f = val < 3 ? f1: f2;
DoWork(f);
}
This works alright for one-off solution, but ends up with a pretty messy header for multiple functions declarations
.h:
typedef bool (*DoWorkFunc1)(uint32_t dParam1, uint32_t dParam2, bool bParam, float fParam1, float fParam2, MyClass& c1, MyClass2& c2);
#define DoWorkLambda1 [](uint32_t dParam1, uint32_t dParam2, bool bParam, float fParam1, float fParam2, MyClass& c1, MyClass2& c2) -> bool
void DoWork1(DoWorkFunc1 func);
typedef bool (*DoWorkFunc2)(uint32_t dParam1, uint32_t dParam2, bool bParam, float fParam1, float fParam2, MyClass& c1, MyClass3& c2);
#define DoWorkLambda2 [](uint32_t dParam1, uint32_t dParam2, bool bParam, float fParam1, float fParam2, MyClass& c1, MyClass3& c2) -> bool
void DoWork2(DoWorkFunc2 func);
...
For reference, this is what the code looks like without the preprocessor:
.h:
typedef bool (*DoWorkFunc)(uint32_t dParam1, uint32_t dParam2, bool bParam, float fParam1, float fParam2, MyClass& c1, MyClass2& c2);
void DoWork(DoWorkFunc func);
.cpp:
bool MyClass::MyFunc(uint32_t val) {
DoWork([](uint32_t dParam1, uint32_t dParam2, bool bParam, float fParam1, float fParam2, MyClass& c1, MyClass2& c2) -> bool
{
return c2.mVal < c1.mVal + fParam1 + fParam2;
}
);
auto f1 = [](uint32_t dParam1, uint32_t dParam2, bool bParam, float fParam1, float fParam2, MyClass& c1, MyClass2& c2) -> bool
{
return (bParam ? dParam1 : c1.mVal) < mVal;
};
auto f2 = [](uint32_t dParam1, uint32_t dParam2, bool bParam, float fParam1, float fParam2, MyClass& c1, MyClass2& c2) -> bool
{
return ((dParam1 & dParam2) == 0) == bParam;
};
auto f = val < 3 ? f1: f2;
DoWork(f);
}

Answer 1

It should be possible to assign a lambda function to the equivalent raw function pointer, but ONLY if it does NOT use the scope arguments - i.e. the square brackets in the lambda declaration MUST be empty.
So you should be able to declare the function type. The using syntax is easiest:
using DoWorkFnType =bool (uint32_t , uint32_t , bool , float , float , MyClass& , MyClass2& );
void DoWork(DoWorkFnType* fn);
bool MyClass::MyFunc(uint32_t val) {
DoWorkFnType* f1 = [](uint32_t dParam1, uint32_t dParam2, bool bParam, float fParam1, float fParam2, MyClass& c1, MyClass2& c2) -> bool
{
return (bParam ? dParam1 : c1.mVal) < mVal;
};
DoWorkFnType* f2 = [](uint32_t dParam1, uint32_t dParam2, bool bParam, float fParam1, float fParam2, MyClass& c1, MyClass2& c2) -> bool
{
return ((dParam1 & dParam2) == 0) == bParam;
};
auto f = val < 3 ? f1: f2;
DoWork(f);
}
void DoWork(DoWorkFnType* fn)
{
bool res= fn(arg1,arg2,arg3,arg4,arg5.arg6,arg7);
}
If your lambda uses the local scope then only std::function will work to pass the lambda to a child function.
It is not clear at all from your code what you expect DoWork to do, or how it gathers the 7 argument values needed to call f, so I will need to leave it there.

Answer 2

.h:
struct DoWorkParams {
uint32_t dParam1;
uint32_t dParam2;
bool bParam;
float fParam1;
float fParam2;
MyClass& c1;
MyClass2& c2;
};
typedef bool (*DoWorkFunc)(DoWorkParams);
void DoWork(DoWorkFunc func);
.cpp:
bool MyClass::MyFunc(uint32_t val) {
DoWork([](auto p) { return p.c2.mVal < p.c1.mVal + p.fParam1 + p.fParam2; } );
auto f1 = [](auto p) { return (p.bParam ? p.dParam1 : p.c1.mVal) < p.mVal; };
auto f2 = [](auto p) { return ((p.dParam1 & p.dParam2) == 0) == p.bParam; };
auto f = val < 3 ? f1: f2;
DoWork(f);
}
in c++11 you need to change auto p to DoWorkParams p, but the auto feature of lambdas was one of the first c++14 features that compilers supported, so it probably works.
If multiple different functions share parameters, you can use inheritance.
struct DoWorkBaseParams {
uint32_t dParam1;
uint32_t dParam2;
bool bParam;
float fParam1;
float fParam2;
};
struct DoWorkParams1:DoWorkBaseParams {
MyClass& c1;
MyClass2& c2;
};
struct DoWorkParams2:DoWorkBaseParams {
MyClass& c1;
MyClass3& c3;
};
etc