How to Make a helper function which accepts a lambda in C++

Right now I have a function which makes some changes in an array of uchar (will act as a LUT) so I can decide which transformation will be implemented on that LUT.

for (size_t i = 0; i <= 255; ++i)
{
    lut_transform[0].at<uchar>(i) = 255-i; //Inverse function
}
for (size_t i = 0; i <= 255; ++i)
{
    lut_transform[1].at<uchar>(i) = pow((float)i * 255,(1/2.0)); //Square Root function
}
for (size_t i = 0; i <= 255; ++i)
{
    lut_transform[2].at<uchar>(i) = pow((float)i, 3.0) / (255*255); //Cubic function
}

So I want to improve this and create a helper function which receives as a parameter the array and the function algorithm to implement. So should look something like this.

void transform_function_helper (std::vector<uchar>& vec_tf, lambda_arg f(int)){
  for (int i = 0; i < vec_tf.size(); ++i) {
    vec_tf.at<uchar>(i) = f(i);
  }
}
void current_function_already_working(){
  /* code */
  //replacing the 3 for for the calls to the helper function
  //lut_transform is a vector of uchar vector
  transform_function_helper(lut_transform[0], [](const int x) -> uchar { 255 - x; } );
  transform_function_helper(lut_transform[1], [](const int x) -> uchar { pow((float)x * 255,(1/2.0)); } );
  transform_function_helper(lut_transform[2], [](const int x) -> uchar { pow((float)x, 3.0) / (255*255); } );
  /*code*/
}

I hope this is clear.

You have three choices:

1. use a plain C-style function pointer (since you are not using any capturing lambdas), eg:

void transform_function_helper (std::vector<uchar>& vec_tf, uchar (*f)(size_t)) {
  for (size_t i = 0; i < vec_tf.size(); ++i) {
    vec_tf[i] = f(i);
  }

  /* alternatively:
  size_t i = 0;
  for (auto &elem : vec_tf) {
    elem = f(i++);
  }
  */
}

2. Use std::function, eg:

#include <functional>

void transform_function_helper (std::vector<uchar>& vec_tf, std::function<uchar(size_t)> f) {
  for (size_t i = 0; i < vec_tf.size(); ++i) {
    vec_tf[i] = f(i);
  }

  /* alternatively:
  size_t i = 0;
  for (auto &elem : vec_tf) {
    elem = f(i++);
  }
  */
}

3. Use a template function, eg:

template<typename Callable>
void transform_function_helper (std::vector<uchar>& vec_tf, Callable f) {
  for (size_t i = 0; i < vec_tf.size(); ++i) {
    vec_tf[i] = f(i);
  }

  /* alternatively:
  size_t i = 0;
  for (auto &elem : vec_tf) {
    elem = f(i++);
  }
  */
}

Either way, you can then call the helper function like this:

void current_function_already_working(){
  /* code */
  //replacing the 3 for for the calls to the helper function
  //lut_transform is a vector of uchar vector
  transform_function_helper(lut_transform[0], [](size_t x) -> uchar { return 255 - x; } );
  transform_function_helper(lut_transform[1], [](size_t x) -> uchar { return pow((float)x * 255,(1/2.0)); } );
  transform_function_helper(lut_transform[2], [](size_t x) -> uchar { return pow((float)x, 3.0) / (255*255); } );
  /*code*/
}

This is what std::transform does. If you use C++20 or newer, you can use std::ranges::transform:

#include <algorithm>
#include <cmath>
#include <vector>

int main(){
    using uchar = unsigned char;

    std::vector<uchar> data{3, 5, 8};

    std::ranges::transform(data, data.begin(),
        [](const uchar x) {
            return static_cast<uchar>(255 - x);
        });

    std::ranges::transform(data, data.begin(),
        [](const uchar x) {
            return static_cast<uchar>(std::pow(x * 255, 0.5));
        });

    std::ranges::transform(data, data.begin(),
        [](const uchar x) {
            return static_cast<uchar>(std::pow(x, 3.0) / (255 * 255));
        });
}

Note that std::pow automatically casts to double if use use integer arguments. Also note that I replaced the lambdas parameter type to uchar which is the vectors actual type. The explicit static_cast in the lambdas is better then explicit return type notation, because it suppresses implicit conversion warnings.

The pre C++20 (C++11) code would be:

#include <algorithm>
#include <cmath>
#include <vector>

int main(){
    using uchar = unsigned char;

    std::vector<uchar> data{3, 5, 8};

    std::transform(data.cbegin(), data.cend(), data.begin(),
        [](const uchar x) {
            return static_cast<uchar>(255 - x);
        });

    std::transform(data.cbegin(), data.cend(), data.begin(),
        [](const uchar x) {
            return static_cast<uchar>(std::pow(x * 255, 0.5));
        });

    std::transform(data.cbegin(), data.cend(), data.begin(),
        [](const uchar x) {
            return static_cast<uchar>(std::pow(x, 3.0) / (255 * 255));
        });
}