我可以在 C++ 中创建通用 function 指针吗？

Question

I've got the following methods:

Matrix& relu(float threshold, Matrix& M)
Matrix& softmax(Matrix& M)

I'd like to have a function pointer that could receive any of these two methods, is that even possible in C++? If not are there any elegant workarounds?

Thanks

Answer 1

Technically, you can point to both functions with any function pointer. You'll just need to convert the type explicitly. Of course, you won't be able to call through the pointer if the type does not match.

Another option is to store the function pointer in a type erasing wrapper such as std::any or std::variant , which provide a visitation mechanic that may be useful.

So, you do have ways of pointing to the different functions, but another matter is whether doing so is in any way useful.

Answer 2

You can use a generic function wrapper std::function :

Matrix& relu(float threshold, Matrix& M);
Matrix& softmax(Matrix& M);

// Accepts a reference to Matrix, returns a reference to Matrix.
// It probably modifies the input matrix in-place.
using F = std::function<Matrix&(Matrix& M)>; 

int main() {
    F f1{softmax};

    float threshold = 0.1; // threshold gets copied into the lambda capture below.
    F f2{[threshold](Matrix& M) -> Matrix& { return relu(threshold, M); }};

    Matrix m;
    Matrix& m2 = f1(m);
    Matrix& m3 = f2(m);
}

---

Your activation functions relu and softmax should probably accept a reference to a const vector and return a new vector by value.

Answer 3

There is a run time solution, which would bit a bit slower and where you would have to check which type it is

#include <iostream>
#include <functional>
#include <variant>

struct Matrix {
    float test{0};
};

Matrix& relu(float threshold, Matrix& M) {
    M.test = threshold;
    return M;
}
Matrix& softmax(Matrix& M) {
    M.test = 42;
    return M;
}

using matrix_generic_function_pointer_t =
        std::variant<std::function<Matrix&(Matrix&)>, std::function<Matrix& (float, Matrix&)>>;

void use_function(matrix_generic_function_pointer_t function_pointer) {
    Matrix m{}; float something = 1337;

    if (function_pointer.index() == 0) {
        std::cout << "Softmax(): " << std::get<std::function<Matrix&(Matrix&)>>(function_pointer)(m).test;
    } else {
        std::cout << "Relu(): " << std::get<std::function<Matrix& (float, Matrix&)>>(function_pointer)(something,m).test;
    }

}

int main()
{
    matrix_generic_function_pointer_t func1{&relu};
    matrix_generic_function_pointer_t func2{&softmax};

    use_function(func1);

    use_function(func2);

    std::cout << "\n";

}

---

And there is also a compile time version, which is faster and safer to use, since it will not fail at run time but instead generate a compiler error, but then is a bit more inflexible for you code:

#include <iostream>
#include <functional>

struct Matrix {
    float test{0};
};

Matrix& relu(float threshold, Matrix& M) {
    M.test = threshold;
    return M;
}
Matrix& softmax(Matrix& M) {
    M.test = 42;
    return M;
}

template <typename F>
void use_function(F&& function) {
    Matrix m{};

    std::cout << function(m).test << "\n";
}

int main()
{
    use_function(std::bind(&relu, 1337, std::placeholders::_1));

    use_function(&softmax);

    std::cout << "\n";
}