4

抽象的

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

介绍

优化问题本质上是很多（数学）函数。问题函数是在类外定义的，而子问题函数是在类内定义的，所以它们有不同的类型（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。创建一个std::function超过 10 个变量的变量似乎是可能的（已编译，但我没有测试）

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

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

4

1 回答 1

3

std::function,std::bind和 lambda 是您正在寻找的。总之，函数指针是很不好的东西，应该被烧死。总之，std::function可以存储任何可以使用正确签名调用的函数对象，并且您可以使用std::bindlambda 生成一个函数对象，该函数对象可以快速轻松地调用您的成员函数。

编辑：然后你只需要推出你自己的std::function支持超过 10 个参数的等价物。

于 2012-10-30T19:53:29.693 回答