Question

假设我有两个不同的类，如下所示

class Nonlinear
{
   public:
   double NonlinearFunc(ParameterList) //it is a nonlinear function 
};

class Solver
{
   public:
   double FuncEvaluation(ParameterList) //evaluate a function
};

double Solver::FuncEvaluation(ParameterList)
{
    ????? //evaluate function from other class
}

main()
{
    Nonlinear nl;
    Solver solve;
    double a;
    double b;
    a = nl.NonlinearFunc(ParameterList);
    b = solve.FuncEvaluation(ParameterList);

    //what I want is a=b
}

如何使用成员函数指针，以便Solver :: FunEvaluation评估Nonlinear :: NonlinearFunc？

Answer 1

听起来您希望Solver::FuncEvaluation()执行Nonlinear::NonlinearFunc()，这是正确的吗？如果是这样，我会这样做：

class Evaluatable
{
public:
   virtual double Evaluate(ParameterList) = 0;
};


class Nonlinear : public Evaluatable
{
public:
   double Evaluate(ParameterList);
};

class Solver
{
public:
   double FuncEvaluation(Evaluatable &expression, ParameterList);
};

double Solver::FuncEvaluation(Evaluatable &expression, ParameterList params)
{
    return expression.Evaluate(params);
}

main()
{
    Nonlinear nl;
    Solver solve;
    double a;
    a = solve.FuncEvaluation(nl, ParameterList);
}

Answer 2

如果你只想评估这个函数，你实际上不需要使用指向成员的指针，你可以直接调用：

class Solver
{
 public:
   Solver(Nonlinear& nl) : mNl(nl) {}
   double FuncEvaluation(ParameterList) //evaluate a function
 private:
   Nonlinear& mNl;
}; 

Solver::FuncEvaluation(ParameterList l)
{
  return mNl.NonLinearFunc(l);
}

否则你必须使用指向成员函数的指针并仍然传递对象实例。

Answer 3

您想从NonLinear::NonLinearFunc()致电Solver::FuncEvaluation。

由于您的课程Solver不是来自课程NonLinear，而NonLinearFunc()是课程NonLinear的成员函数，您必须拥有FuncEvaluation类x的对象（我们称之为NonLinear），例如，其中一个参数。

如果是这种情况，您不需要指向成员函数的指针，只需调用函数：

 x.NonLinearFunc(...)   // or x->NonLinearFunc(...) if you work with pointers.

如果您有几个类似的成员函数并且想要动态选择一个成员函数，那么指向成员函数的指针才有意义。

修改：

使用指向成员函数的指针时，如果确实需要，请执行以下操作：

double (NonLinear::*f)(...); // declare a pointer to a member function of Nonlinear
f = &A::NonLinearFunc;       // Assign the address of the function to the pointer.  Note the mandatory &    
(x.*f)(...);                 // call the function pointed to, using NonLinear object x with the given parameters

请注意，在此示例中，指针f不是NonLinear的成员，而是具有类型“指向类NonLinear的成员函数的指针”的变量。它将是你的解算器的变量。

Answer 4

听起来你希望函数FuncEvaluation能够接受任何（成员）函数作为参数，并使用自己的参数对其进行评估。

在现代C ++中，您可以执行类似¹：

的操作

struct Solver {
    template <typename Callable, typename... Args>
    auto funcEvaluation(Callable&& c, Args&&... args) {
        return std::forward<Callable>(c)(std::forward<Args>(args)...);
    }
};

并使用它，例如：

struct NonLinear {
    /* Some member function */
    double nonLinearFunc(double x, double y, int m) {
        return (x + y) * m; // (Not non-linear but serving as a simple example.)
    }
};

int main() {
    Solver s;
    NonLinear nl;

    // Use standard library call wrapper for member functions.
    auto c = std::mem_fn(&NonLinear::nonLinearFunc);

    // When using call wrapper you need to pass instance 'nl' as parameter.
    std::cout << s.funcEvaluation(c, nl, 1.0, 2.0, 2) << std::endl;

    // Outputs 6.0
}

Live example

_{1：您需要C ++ 1y支持函数返回类型推导才能工作。}

C ++从其他类端口成员函数

4 个答案: