I need to implement a c++ function pointer to member function overload - c++

Question

arma::Mat<double> (*Sum)(arma::Mat<double>, int) = arma::sum; // The function pointer to arma::sum
arma::Mat<double> mat = Sum(A, 1); //A is of type arma::Mat<double>
std::cout<<mat;
produces the error :
error: no matches converting function ‘sum’ to type ‘class arma::Mat<double> (*)(class arma::Mat<double>, int)’
arma::Mat<double> (*Sum)(arma::Mat<double>, int) = &arma::sum;
I'm unable to understand this as
arma::Mat<T> mat;
mat = arma::sum(this->data, 1);
std::cout<<mat;
produces the desired result when the template T is of type double.Please help me out,thanks!!
The prototype for arma::sum in Armadillo documentation is given as:
sum( M )
sum( M, dim ) //dim = 0, 1 for rowise or columnwise sum

Answer 1

Just because the result can be assigned to a variable of a certain type, that doesn't mean that, that is the signature of the method.
A function can return a type which can be converted or assigned to a variable of another type.
In this case, to solve the problem - the original function has to be checked for it's signature (in the header files).
Then it will be possible to create the correct signature, expecially if there are overloads of the function.
For example, a signature from the Armadillo project:
template<typename T1>
arma_warn_unused
arma_inline
const Op<T1, op_sum>
sum
(
const T1& X,
const uword dim = 0,
const typename enable_if< is_arma_type<T1>::value == true >::result* junk1 = 0,
const typename enable_if< resolves_to_vector<T1>::value == false >::result* junk2 = 0
)
// ignore the implemenation ...
As can be seen this function returns an Op type which is a template class. The function has 2 usefull for the user parameters and 2 metaprogramming parameters, used by the implementation.
If you call this function with the type arma::Mat<double> then the signature of this chosen function is:
const Op<arma::Mat<double>, op_sum> (*sum_func)(const arma::Mat<double>, const uword, const void*, const void*)
As I can see in the header file, 11 definitions for sum function are provided. Then also metaprogramming is used to improve the performance of the implementation, which also increases the amount of combinations of parameters for this function, which means even more definitions.
So the type of this function is actually quite compilcated. And because of the metaprogramming it is not necassarily the one which is used, when it is called.
To help with the deduction of the return type decltype can be used.
class Test
{
public:
int sum (int i){return 1;}
float sum (float i){return 2.0;}
};
int main()
{
Test t;
decltype(t.sum(0)) (Test::* sum_ptr)(int) = &Test::sum;
return (t.*sum_ptr)(0);
}

Answer 2

I keep a helper function around just for this kind of cases, whare you want to resolve an overload without caring about the return type:
template <class... Params, class R>
auto ovl(R(*f)(Params...)) {
return f;
}
Your initialization then becomes:
auto Sum = ovl<arma::Mat<double>, int>(arma::sum);