使用 dlib 的成员函数指针未在此范围内声明答案

【问题标题】：member function pointer using dlib was not declared in this scope使用 dlib 的成员函数指针未在此范围内声明
【发布时间】：2018-08-30 11:40:06
【问题描述】：

我正在寻找使用 dlib 库优化近似误差... 所以假设我有 Point (x,y) 和一个值向量，它们用于查找最小值并在本地拟合错误，所以我实现了这个类：

#include <iostream>
#include <vector>
#include <cmath>
#include <dlib/optimization.h>
class Point
{
   int _x, _y;
public:
    Point(int x, int y): _x(x), _y(y){}

    double findError(const double& psi)
    {
        auto err = std::erf(_x - psi) - std::erf(_y-psi);
        return std::pow(err,2);
    }
    double optimize(const Point& p, dlib::matrix<double,0,1> &psiValues)
    {
         auto err = p->*findError ;
         dlib::find_min_box_constrained(bfgs_search_strategy(),  
                             objective_delta_stop_strategy(1e-9),  
                             findError, derivative(findError), psiValues, {0.1,0.5,0.9},{0.1,0.4,0.8 });
        return psiValues(0);
    }
};

并且这段代码无法编译，所以我尝试在静态类中提取优化器，如下所示：

#include <iostream>
#include <vector>
#include <cmath>
//#include <dlib/optimization.h>
class Point
{
   int _x, _y;
public:
   Point(int x, int y): _x(x), _y(y){}

    double findError(const double& psi)
   {
       auto err = std::erf(_x - psi) - std::erf(_y-psi);
       return std::pow(err,2);
   }
};

class Errorcalculator
{
public:

    static double optimize(const Point& p, std::vector<double> &psiValues)
    {
        auto err = p->*findError ;
        // dlib::find_min_box_constrained(bfgs_search_strategy(),  
        //                     objective_delta_stop_strategy(1e-9),  
        //                     p->*findError, derivative(p->*findError), psiValue, {0.1,0.9 },{0.1 0.8});
        return 0.0;
    }
 };

现在我得到了（使用带或不带 static 关键字的 dlib 函数出现相同的编译错误）

错误：'findError' 未在此范围内声明

如果点p被声明为参数怎么可能？如何使用类中封装的 dlib 函数？

【问题讨论】：

标签： c++ optimization dlib member-function-pointers

【解决方案1】：

根据acade的回答，编译的问题解决了。但是我在这里添加我的解决方案作为解决使用 Dlib 库的答案

 #include <iostream>
 #include <vector>
 #include <cmath>
 #include <dlib/optimization.h>
 class Point
 {
    int _x, _y;
 public:
    Point(int x, int y): _x(x), _y(y){}

    double findError(const double& psi)
    {
        auto err = std::erf(_x - psi) - std::erf(_y-psi);
        return std::pow(err,2);
    }
    double optimize(double &psiValue, dlib::matrix<double,0,1>& lowerValues, dlib::matrix<double,0,1>& upperValues)
    {
        auto lambdaError = [this](const double& param) -> double
         { return this->findError(param);};

        auto lambdaDerivativeError = [this](const double& param) -> double 
         {return dlib::derivative(lambdaError)(param);};

        dlib::find_min_box_constrained(bfgs_search_strategy(),  
                         objective_delta_stop_strategy(1e-9),
                         lambdaError, lambdaDerivativeError, 
                         psiValue, lowerValues, upperValues);
        return psiValue;
    }


 };

这个想法是使用封装成员函数的参数化 Lambda 函数

【讨论】：

【解决方案2】：

findError 是成员方法，但不是指针。要创建指向方法的指针，请使用下一个语法： 返回值 (class_name::* pointer_name)(方法参数); 示例：

class widget
{
public:
    unsigned char foo(long long, double) {}
};
int main()
{
    // declaration of pointer
    unsigned char (widget::*ptr_to_method)(long long, double);
    // setting the pointer on certain method in class (not object!)
    ptr_to_method = &widget::foo;
    // we have some object of widget class
    widget obj{};
    // using the pointer
    unsigned char res = (obj.*ptr_to_method)(10L, 10.0); // arguments
    // if we have obj as widget*, we'll use ->* syntax to call method
}

在这个示例中，我们使用了本地指针，您可能会使用全局指针。阅读更多，例如，here

【讨论】：