c++ - 由 lambda 初始化的函数指针及其作用域

Question

我写了下面的代码，它将对x=a op b 类型的数组进行逐元素转换。 T 是数字类型(float、double、int、uint8_t、uint32_t、...)

template <typename T>
void processFrame(Args ARG, T* a_array, T* b_array, T* x_array, uint32_t elmcount) 
{

    if(ARG.multiply)
    {   
        std::transform(A_array, A_array + elmcount, B_array, x_array, std::multiplies());
    } else if(ARG.divide)
    {   
        std::transform(A_array, A_array + elmcount, B_array, x_array, std::divides());
    } else if(ARG.min)
    {   
        std::transform(A_array, A_array + elmcount, B_array, x_array, [](T i, T j) {return std::min(i, j);});
    }   
}

此代码的问题是我需要多次重复 std::transform 行，但只有转换类型真正发生变化。谷歌搜索后，我最终使用了指向由 lambda 填充的函数的指针。

template <typename T>
using Operator = T (*)(const T&, const T&);

template <typename T>
void processFrame(Args ARG, T* A_array, T* B_array, T* x_array, uint32_t elmcount)
{
    Operator<T> op = nullptr;

    if(ARG.multiply)
    {   
        op = [](const T &i, const T &j) { return T(i * j); };
    } else if(ARG.divide)
    {
        op = [](const T &i, const T &j) { return T(i / j); };
    } else if(ARG.inverseDivide)
    {
        op = [](const T &i, const T &j) { return T(j / i); };
    } else if(ARG.add)
    {
        op = [](const T &i, const T &j) { return T(i + j); };
    } else if(ARG.subtract)
    {
        op = [](const T &i, const T &j) { return T(i - j); };
    } else if(ARG.max)
    {
        op = [](const T &i, const T &j) { return std::max(i, j); };
    } else if(ARG.min)
    {
        op = [](const T &i, const T &j) { return std::min(i, j); };
    }
    std::transform(A_array, A_array + elmcount, B_array, x_array, op);
}

现在它可以工作了，但我不确定我是否没有使用未分配的内存。由于 op 是正式的指针并且我通过 lambda 初始化它，那么 lambda 是否会在每个 if block 的末尾超出范围？我的 std::transfrom 没有使用指向不存在对象的指针吗？

Answer 1

代码是安全的。

函数指针在整个程序长度内都是有效的(dlopen 东西除外...)。

没有捕获的 Lambda 可以通过 magic 隐式转换为函数指针.每个 lambda 表达式都会创建一个不同的类型并返回该类型的新对象。

是的，对象超出了范围，但类型当然没有，它的静态方法也没有，它们将是存储在指针内的函数。