Передача указателя на функцию-член в функцию без класса - PullRequest
Новая
       13

Передача указателя на функцию-член в функцию без класса

0 голосов
/ 13 января 2012

В приведенном ниже коде я не могу найти способ передачи функции-члена в общий корень искателя. 

#include <stdio.h>

double OneDimBisector(double (*fun)(float), float a, float b, float tol){
 double val;                                                                                                                                                                           
 val = (*fun)(0.5*(b-a));    // actually: do proper bisection                                                                                                                          
 return val;                                                                                                                                                                           
}                                                                                                                                                                                      

class EOS {                                                                                                                                                                            
 public:                                                                                                                                                                               
  double S_array[10][10];    // actually: filled by constructor                                                                                                                        
  double S(double T, double P);                                                                                                                                                        

  double T_PS(double P, double S);                                                                                                                                                     
  double functForT_PS(double T);                                                                                                                                                       
  double (EOS::*pfunctForT_PS)(double);                                                                                                                                                
  double Sseek, Pseek;                                                                                                                                                                 
};                                                                                                                                                                                     


double EOS::S(double T, double P){                                                                                                                                                     
  double val = T+P;          // actually: interpolate in S_array                                                                                                                       
  return val;                                                                                                                                                                          
}                                                                                                                                                                                      

double EOS::functForT_PS(double T){                                                                                                                                                    
 return S(T,Pseek)-Sseek;                                                                                                                                                              
}                                                                                                                                                                                      

// Find T from P and S (T is invertible), assuming the intervals are ok
double EOS::T_PS(double P, double S0){
  double Tmin = 2., Tmax = 7., T1, tol=1e-8;
  pfunctForT_PS = &EOS::functForT_PS;
  Sseek = S0;
  Pseek = P;

  printf("\n %f\n", (*this.*pfunctForT_PS)(4.));         // no problem
  T1 = OneDimBisector(pfunctForT_PS, Tmin, Tmax, tol);   // wrong type for pfunctForT_PS

  return T1;
}

int main() {
  double P=3., S=8;
  EOS myEOS;

  printf("\n %f %f %f\n",P,S,myEOS.T_PS(P,S));
}

Я не хочу делать root-искатель участником, потому что он не специфичен для этого класса, и решение сделать все static кажется очень не элегантным. Будет ли у кого-нибудь идея? Должно быть, это обычная ситуация, но я не нашел соответствующего поста, который также был бы мне понятен.

Спасибо!

Редактировать: Собственно, я также хотел спросить: существует ли правильный, потокобезопасный способ установки переменной Pseek, отличной от той, что я делал? Просто чтобы прояснить: я делаю одномерный поиск корня двумерной функции, но фиксирую один из двух аргументов.

Ответы [ 3 ]

3 голосов
/ 13 января 2012

Один из способов - изменить сигнатуру корневого искателя (добавьте #include <functional>): 

double OneDimBisector(std::function<double(float)> f, float a, float b, float tol);

Затем вызовите его с помощью bind: 

T1 = OneDimBisector(std::bind(pfunctForT_PS, this, std::placeholders::_1),
                    Tmin, Tmax, tol);

Это несет определенные накладные расходы. Если вы не возражаете против дублирования кода, вы можете сделать функцию шаблоном: 

template <typename Func>
double OneDimBisector(Func f, float a, float b, float tol);

Вы вызываете его таким же образом, но каждый раз, когда у вас появляется новый тип функции, в вашем компиляторе создается новый экземпляр шаблона.

«Традиционное» решение состоит в том, чтобы иметь свободную (или статическую) функцию, которая принимает дополнительный аргумент экземпляра.

Обновление: «Традиционное решение»: 

double OneDimBisector(double(*f)(float, void *), void * data, ...);

double EOSBisect(float f, void * data)
{
    EOS * e = static_cast<EOS *>(data); // very "traditional"
    return e->functorForT_PS(f);
}

Использование: T1 = OneDimBisector(EOSBisect, this, Tmin, Tmax, tol);

1 голос
/ 13 января 2012

Вы не можете передать указатель на функцию-член в качестве указателя на функцию, поскольку в последнем отсутствует указатель контекста (this) для правильного вызова указателя на функцию-член.

Общий способ решения этой проблемыв стандартной библиотеке C ++) использовать шаблон: 

template <typename F>
double OneDimBisector(F fun, float a, float b, float tol){
   double val;
   val = fun(0.5*(b-a));
   return val;                                                        
}

и передать ему объект функции 

struct Evaluator
{
   EOS* this_;

   Evaluator(EOS* this_) : this_(this_) {}  // constructor

   double operator()(double value) const    // call the function
   {
       return this_->functForT_PS(value);
   }
};

T1 = OneDimBisector(Evaluator(this), Tmin, Tmax, tol);

Вы также можете использовать std::bind1st(std::mem_fun(&EOS::functForT_PS), this), но этотак же, как структура выше. (Кстати, std :: bind1st и std :: mem_fun устарели.)

Если вам не нравятся шаблоны, вы можете принять полиморфную функциювместо этого (например, используя Boost.Function или std :: function в C ++ 11), но это будет медленнее: 

double OneDimBisector(const boost::function<double(double)>& fun,
                      float a, float b, float tol)
{
    return fun(0.5 * (b-a));
}

и, наконец, если вы можете использовать C ++11, вы можете использовать лямбда-функцию при вызове OneDimBisector: 

T1 = OneDimBisector([=](double value){ return functForT_PS(value); },
                    Tmin, Tmax, tol);
0 голосов
/ 13 января 2012

Проблема, с которой вы сталкиваетесь, заключается в том, что указатель на функцию отличается от указателя на функцию члена.

Общепринятый (Java World) подход для обхода этой проблемы - использование шаблона «Стратегия» (шутка над Биссектором - это некая реализация стратегии).

Обычный подход C ++ - использование функторов / связывания, например с наддувом: 

typedef boost::function<double (double)> MyFun;
double OneDimBisector(const MyFun & fun, float a, float b, float tol){
    double val;                                                                                                                                                                           
    val = fun(0.5*(b-a));    // actually: do proper bisection                                                                                                                          
    return val;                                                                                                                                                                           
}

// Calling
T1 = OneDimBisector (boost::bind (&EOS::functForT_PS, *this), Tmin, Tmax, tol));
...