将乘法类的指针传递给成员函数

Question

我有下一个类:

"Integrator.h"
#include <vector>
#include <array>
using namespace std;
class Integrator {
public:
    using coord_type = array<double, 3>;  
protected:
    void base_integrate_callback(const coord_type, double t_k) {
      //does nothing
    }
};
class MyIntegrator :public Integrator {
public:
   template <class T>
   void integrate(int mp_id, int t_span, int step ,
   void(T::*callback)(const coord_type, double) = (Integrator::*)(const coord_type, double)){
  //calls callback here
}
};
"main.cpp"
#include Integrator.h"
struct caller {
   void callback(const Integrator::coord_type coord, double t_k) {
   //does smth
}
};
int main(){
   MyIntegrator integrator_1;
   caller A;
   int mp_id = 1;
   int span = 365;
   int step = 1;
   integrator_1.integrate<caller>(mp_id,span,step,&A.callback);
   return 0;
}

试图编译它，我得到一个错误:

file:integration.h，第18行，语法错误:'<标签>::*

我如何调用一个回调可以属于任何类?

第二个问题是:当我尝试在没有明确模板规范的情况下调用它时，比如

integrator_1.integrate(mp_id,span,step,&A.callback);

我得到一个错误

file: main.cpp，第65行，'MyIntegrator::integrate':没有找到匹配的重载函数

那么，为什么这个函数不能从它的形参推导出它的实参呢?

也得到同样的错误时，调用它没有最后一个参数依赖于默认参数。

integrator_1.integrate(mp_id,span,step);

Answer 1

通过缩进来解密这里的内容

template <class T>
void integrate(int mp_id, 
               int t_span, 
               int step ,
               void(T::*callback)(const coord_type, double) = (Integrator::*)(const coord_type, double))
{
    //calls callback here
}

看起来你正在尝试声明一个方法，该方法将回调函数作为参数并分配默认值。不幸的是，默认值看起来像是另一个方法指针的声明，而不是一个方法。您需要使用指向T方法的指针。

template <class T>
void integrate(int mp_id, 
               int t_span, 
               int step ,
               void(T::*callback)(const coord_type, double) = &Integrator::base_integrate_callback)
{
    //calls callback here
}

但我不认为这将是合适的，因为没有办法确保T和Integrator有任何相关。

例如，在清理

之后

integrator_1.integrate < caller > (mp_id, span, step, &A.callback);

integrator_1.integrate < caller > (mp_id, span, step, &caller::callback);

，因为您需要提供指向方法的指针，而不是指向方法的对象。这暴露了另一个问题，我们稍后会讨论，但现在它可以编译，让我们继续。

但是这不会

integrator_1.integrate < caller > (mp_id, span, step);

因为Integrator::base_integrate_callback的签名void Integrator::base_integrate_callback(const coord_type, double)与void(caller::*callback)(const coord_type, double)的签名不匹配。他们看起来一样，不是吗?缺少的是所有方法都具有的隐藏的this参数。caller::*callback期望caller *，但Integrator::base_integrate_callback提供Integrator *。

你可以通过使caller和它的类似继承Integrator而不是MyIntegrator来解决这个问题，但是将base_integrate_callback移动到新的struct Integrated，并让caller和朋友继承Integrated会更有意义。

回到我之前提到的另一个问题。在

template <class T>
void integrate(int mp_id, 
               int t_span, 
               int step ,
               void(T::*callback)(const coord_type, double) = &Integrated::base_integrate_callback)
{
    coord_type x; // junk for example
    double y; //junk for example
    callback(x,y); //KABOOM!
}

在什么对象上调用回调?integrate还需要一个参数，一个对T的引用，为callback提供上下文。

template <class T>
void integrate(int mp_id, 
               int t_span, 
               int step,
               T & integrated,
               void(T::*callback)(const coord_type, double) = &Integrated::base_integrate_callback)
{
    coord_type x; // junk for example
    double y; //junk for example
    integrated.callback(x,y);
}

那么你必须使用正确的语法来调用函数指针，因为上面的代码总是调用caller::callback。

template <class T>
void integrate(int mp_id, 
               int t_span, 
               int step,
               T & integrated,
               void(T::*callback)(const coord_type, double) = &Integrated::base_integrate_callback)
{
    coord_type x; // junk for example
    double y; //junk for example
    (integrated.*callback)(x,y); //std::invoke would be preferred if available
}

一起:

#include <array>
#include <iostream>
class Integrator
{
public:
    using coord_type = std::array<double, 3>;
};
struct Integrated
{
    void base_integrate_callback(const Integrator::coord_type, double t_k)
    {
        std::cout << "made it to default" << std::endl;
    }
};
class MyIntegrator: public Integrator
{
public:
    template <class T>
    void integrate(int mp_id,
                   int t_span,
                   int step,
                   T & integrated,
            void(T::*callback)(const coord_type, double) = &Integrated::base_integrate_callback)
    {
        coord_type x; // junk for example
        double y = 0; //junk for example
        (integrated.*callback)(x,y);
    }
};

struct caller:public Integrated
{
    char val; // for test purposes
    caller(char inval): val(inval) // for test purposes
    {
    }
    void callback(const Integrator::coord_type coord, double t_k)
    {
        std::cout << "made it to " << val << std::endl;
    }
};
int main()
{
    MyIntegrator integrator_1;
    caller A {'A'};
    caller B {'B'};
    caller C {'C'};
    int mp_id = 1;
    int span = 365;
    int step = 1;
    integrator_1.integrate < caller > (mp_id, span, step, A, &caller::callback);
    integrator_1.integrate < caller > (mp_id, span, step, B, &caller::callback);
    integrator_1.integrate < caller > (mp_id, span, step, C);
    return 0;
}

建议:进入2011年，看看std::function和lambda表达式能为您做些什么。

下面是一个例子:

#include <array>
#include <iostream>
#include <functional>
class Integrator
{
public:
    using coord_type = std::array<double, 3>;
};
// no need for integrated to get default callback
class MyIntegrator: public Integrator
{
public:
    template <class T>
    void integrate(int mp_id,
                   int t_span,
                   int step,
                   // no need to provide object instance for callback. packed with std::bind
                   std::function<void(const coord_type, double)> callback =
                           [](const coord_type, double) { std::cout << "made it to default" << std::endl; })
                           // default callback is now lambda expression
    {
        coord_type x; // junk for example
        double y = 0; //junk for example
        callback(x,y); // no weird syntax. Just call a function
    }
};

struct caller
{
    char val; // for test purposes
    // no need for test constructor
    void callback(const Integrator::coord_type coord, double t_k)
    {
        std::cout << "made it to " << val << std::endl;
    }
};
int main()
{
    MyIntegrator integrator_1;
    caller A {'A'};
    caller B {'B'};
    // no need for test object C
    int mp_id = 1;
    int span = 365;
    int step = 1;
    using namespace std::placeholders; // shorten placeholder names
    integrator_1.integrate < caller > (mp_id, 
                                       span, 
                                       step, 
                                       std::bind(&caller::callback, A, _1, _2));
    // std bind bundles the object and the callback together into one callable package
    integrator_1.integrate < caller > (mp_id, 
                                       span, 
                                       step, 
                                       [B](const Integrator::coord_type p1, 
                                           double p2) mutable // lambda captures default to const 
                                       { 
                                           B.callback(p1, p2); // and callback is not a const method
                                       });
    // Using lambda in place of std::bind. Bit bulkier, but often swifter and no 
    //need for placeholders
    integrator_1.integrate < caller > (mp_id,
                                       span,
                                       step,
                                       [](const Integrator::coord_type p1,
                                           double p2)
                                       {
                                           std::cout << "Raw Lambda. No callback object at all." << std::endl;
                                       });
    //custom callback without a callback object
    integrator_1.integrate < caller > (mp_id, span, step);
    //call default
    return 0;
}