摘要

Question

摘要

我有一个存储优化问题的类，并针对该问题运行求解器。如果求解器失败，我想考虑一个子问题并使用相同的求解器（和类）求解。

简介

优化问题基本上是很多（数学）函数。问题函数在类外部定义，但子问题函数在类中定义，因此它们具有不同的类型（例如void (*)和void (MyClass::*)。

起初我以为我可以将成员函数转换为非成员指针到函数类型，但我发现我不能。所以我正在寻找其他方式。

示例代码

模拟我的问题的示例代码：

#include <iostream>

using namespace std;

typedef void (*ftype) (int, double);

// Suppose foo is from another file. Can't change the definition
void foo (int n, double x) {
  cout << "foo: " << n*x << endl;
}

class TheClass {
  private:
    double value;
    ftype m_function;
    void print (int n, double x) {
      m_function(size*n, value*x);
        }
  public:
    static int size;
    TheClass () : value(1.2), m_function(0) { size++; }
    void set_function (ftype p) { m_function = p; }
    void call_function() {
      if (m_function) m_function(size, value);
    }
    void call_ok_function() {
      TheClass ok_class;
      ok_class.set_function(foo);
      ok_class.call_function();
    }
    void call_nasty_function() {
      TheClass nasty_class;
//      nasty_class.set_function(print);
//      nasty_class.set_function(&TheClass::print);
      nasty_class.call_function();
    }
};
int TheClass::size = 0;

int main () {
  TheClass one_class;

  one_class.set_function(foo);
  one_class.call_function();
  one_class.call_ok_function();
  one_class.call_nasty_function();
}

如示例所示，成员函数不能是静态的。另外，我无法重新定义原始问题函数来接收对象。

感谢您的帮助。

修改

我忘了提。我尝试更改为std :: function，但我的原始函数有超过10个参数（它是Fortran子例程）。

解决方案

我按照建议对std::function和std::bind进行了更改，但没有重新设计具有更多10个参数的函数。我决定创建一个中间函数。以下代码说明了我所做的事情，但变量较少。谢谢大家。

#include <iostream>
#include <boost/tr1/functional.hpp>

using namespace std;

class TheClass;

typedef tr1::function<void(int *, double *, double *, double *)> ftype;

// Suppose foo is from another file. Can't change the definition
void foo (int n, int m, double *A, double *x, double *b) {
    // Performs matrix vector multiplication x = A*b, where
    // A is   m x n
}

void foo_wrapper (int DIM[], double *A, double *x, double *b) {
    foo(DIM[0], DIM[1], A, x, b);
}

class TheClass {
    private:
        ftype m_function;
        void my_function (int DIM[], double *A, double *x, double *b) {
            // Change something before performing MV mult.
            m_function(DIM, A, x, b);
        }
    public:
        void set_function (ftype p) { m_function = p; }
        void call_function() {
            int DIM[2] = {2,2};
            if (m_function) m_function(DIM, 0, 0, 0);
        }
        void call_nasty_function() {
            TheClass nasty_class;
            ftype f = tr1::bind(&TheClass::my_function, this, _1, _2, _3, _4);
            nasty_class.set_function(f);
            nasty_class.call_function();
        }
};

int main () {
    TheClass one_class;

    one_class.set_function(foo_wrapper);
    one_class.call_function();
    one_class.call_nasty_function();
}

PS。使用

创建一个包含10个以上变量的std::function似乎是可能的（已编译，但我没有测试）

#define BOOST_FUNCTION_NUM_ARGS 15
#include <boost/function/detail/maybe_include.hpp>
#undef BOOST_FUNCTION_NUM_ARGS

但为超过10个参数创建std::bind似乎并不容易。

Answer 1

您正在寻找

std::function，std::bind和lambdas。简而言之，函数指针是非常糟糕的东西，应该被烧毁。总之，std::function可以存储任何可以使用正确签名调用的函数对象，并且可以使用std::bind或lambda生成一个快速，轻松地调用成员函数的函数对象。

编辑：然后您只需要滚动自己的std::function等效项，支持超过10个参数。

指向函数成员和非成员的指针

摘要

简介

示例代码

修改

解决方案

1 个答案: