Create multiple function pointers for callbacks with different parameters in C++ - c++

Question

I have a third party class Calculation with a function setCallback:
typedef void (*callback_function)(void);
class Calculation
{
public:
void setCallback(callback_function pFunc);
};
and my function I want to use as callback
void callback(int id);
I want to create, say, four (number known at compile time) objects of Calculation and set the callback for each object. I could do something like
void callback0() { callback(0); }
void callback1() { callback(1); }
void callback2() { callback(2); }
void callback3() { callback(3); }
int main() {
std::vector<Calculation> vec;
for (int i = 0; i < 4; i++) {
Calculation c = Calculation();
vec.push_back(c);
}
vec[0].setCallback(callback0);
vec[1].setCallback(callback1);
vec[2].setCallback(callback2);
vec[3].setCallback(callback3);
return 0;
}
Question: How can I achieve this without duplicating and repeating code?
I was thinking of lamdas, like
for (int i = 0; i < 4; i++) {
Calculation c = Calculation();
c.setCallback([i]() -> void {callback(i);});
vec.push_back(c);
}
but a lambda can only be converted to a function pointer if it does not capture.

Answer 1

Template function might help:
template <int N>
void callbackN() { callback(N); }
and then
vec[0].setCallback(callback<0>);
vec[1].setCallback(callback<1>);
vec[2].setCallback(callback<2>);
vec[3].setCallback(callback<3>);

Answer 2

Since the number of Calculation instances is known at compile-time, you set up something like this to automate things, but not sure if it's worth the effort:
template <size_t Size, typename Idx = std::make_index_sequence<Size>>
class CalcInterface {
std::array<callback_function, Size> m_callbacks { makeCallbacks(Idx{}) };
std::array<Calculation, Size> m_calcs;
protected:
template <size_t N>
static inline callback_function makeCallback() {
return []{ return callback(N); };
}
template <size_t... Seq>
static inline auto makeCallbacks(std::index_sequence<Seq...>) {
std::array<callback_function, Size> arr;
((arr[Seq] = makeCallback<Seq>()), ...);
return arr;
}
static void callback(int id) {
std::cout << "Callback #" << id << " was called\n";
}
public:
CalcInterface() {
for (size_t i=0; i<Size; ++i) {
m_calcs[i].setCallback(m_callbacks[i]);
}
}
void runAll() const {
for (auto& calc: m_calcs) calc.run();
}
};
Example here: https://godbolt.org/z/sWTzn59ce