std::tr1::function et std::tr1::bind

Si vous essayez juste de passer d'une fonction membre dans un style c rappel, vous pouvez le faire avec l'aide d' std::t1::bind ou std::tr1::function.

class myIntegrator
{
public:
   //getValue is no longer const.  but integrandF2 wasn't changed
   double getValue( double x, double Q2 )
   {
      m_x = x;
      m_Q2 = Q2;

      //these could be members if they need to change
      const double xMin[3] = {0.0};
      const double xMax[3] = {1.0,1.0,1.0};
      const unsigned maxEval = 0;
      double reqAbsError = 0.0;
      double reqRelError = 1e-4;

      double val;

      adapt_integrate( 1, &myIntegrator::fancy_integrand,
                       reinterpret_cast<void*>(this),
                       3, xMin, xMax,
                       maxEval, reqAbsError, reqRelError,
                       &val, &m_err);

      return val;
   }

   double get_error()
   { return m_error; }

private:
   //use m_x and m_Q2 internally
   //I removed the unused void* parameter
   double integrandF2( unsigned ndim, const double *x,
                       unsigned fdim, double *fval) const;

   static double fancy_integrand( unsigned ndim, const double* x, void* this_ptr,
                                  unsigned fdim, double* fval)
   {
      myIntegrator& self = reinterpret_cast<myIntegrator*>(this_ptr);
      self.integrateF2(ndim,x,fdim,fval);
   }

   double m_x
   double m_Q2;
   double m_err;
};

OriginalL'auteur deft_code

Depuis std::tr1::bind et c-style des pointeurs de fonction ne s'entendent pas, essayez plutôt ceci. Il va travailler, sauf que myIntegrator::getValue n'est pas plus "thread-safe". Si calcTripleIntegral ont été retirés de l'interface, ce serait encore plus simple et n'aurait pas besoin d'utiliser std::tr1::bind ou std::tr1::function.

class myIntegrator
{
public:
   double getValue( double x, double Q2 ) const
   {
       return calcTripleIntegral(x,Q2,std::tr1::bind(&Integrator::integrandF2,this));
   }

   double calcTripleIntegral( double x, double Q2, const std::tr1::function<integrand>& func ) const
   {
      assert( s_integrator == NULL );
      s_integrator = this;
      m_integrand = func;

      //...declare val, err, xMin, xMax and input(x,Q2) ...//
      adapt_integrate( 1, &myIntegrator::fancy_integrand, input,
                       3, xMin, xMax,
                       0, 0, 1e-4,
                       &val, &err);

      assert( s_integrator == this);
      s_integrator = NULL;

      return val;
   }
private:
   double integrandF2( unsigned ndim, const double *x, void *,
                unsigned fdim, double *fval) const;

   static double fancy_integrand( unsigned ndim, const double* x, void* input,
                                  unsigned fdim, double* fval)
   {
      s_integrator->integrateF2(ndim,x,input,fdim,fval);
   }

   std::tr1::function<integrand> m_integrand;
   static const myIntegrator* s_integrator;
};

OriginalL'auteur deft_code

Faisant l'hypothèse que la C-API permet le passage d'un type de diagnostic (dans le sens que le C-la fonction de l'API n'a pas à connaître son type, mais s'appuie sur la fonction de rappel pour savoir ce qu'il implique) paramètre de contexte (ce qui est généralement le cas avec des fonctions de rappel; dans ce cas, je soupçonne le fdata paramètre être quelque chose le long de ces lignes), passez à la fonction de l'objet dans le cadre de ce paramètre de contexte.

Il devrait alors ressembler à ceci:

#include <iostream>
#include <tr1/functional>

typedef void (*callback_function_t)(void *input, int arg);

struct data_type { 
  int x;
};

struct context_type {
  std::tr1::function<void(data_type const &, int)> func;
  data_type data;
};

void callback(data_type const&data, int x) {
  std::cout << data.x << ", " << x << std::endl;
}

void callback_relay(void *context, int x) {
  context_type const *ctxt = reinterpret_cast<context_type const*>(context);
  ctxt->func(ctxt->data, x);
}

void call_callback(callback_function_t func, void *context, int x) {
  func(context, x);
}

int main() {
  context_type ctxt = { callback, { 1 } };

  call_callback(callback_relay, &ctxt, 2);
}

Où call_callback est la C-fonction de l'API. De cette façon, vous pouvez assigner n'importe quoi que vous voulez qui prend en charge la fonction de la syntaxe d'appel de context_type::func, y compris std::tr1::bind expressions. Aussi, même si je me sens moralement obligé de le mentionner), il n'est pas, à proprement parler, défini dans la norme que les conventions d'appel C et C++ les fonctions sont les mêmes, dans la pratique, vous pourriez faire context_type un modèle de classe et de callback_relay un modèle de fonction pour faire context_type::des données plus flexible et réussir tout ce que vous voulez de cette façon.

OriginalL'auteur Anonymous Coward

bind fonctionne un peu différente de ce que vous supposez, je pense. Vous devez fournir une valeur, ou un espace réservé pour chaque argument.

Pour votre exemple, cela revient à l' (avec espaces)

std::tr1::function<integrand> func(std::tr1::bind(&myIntegrator::integrandF2, *this, _1, _2, _3, _4, _5));

Puisque vous êtes à la liaison d'une fonction membre, vous avez un supplément (implicite) de l'argument, c'est à dire l'objet que vous appelez la fonction membre, de sorte que vous disposez de six.

Pour la première vous lier la this objet, pour les autres arguments, il vous suffit de passer espaces réservés.

Sur une note de côté, votre membre de la fonction renvoie un double, tandis que la déclaration de la fonction renvoie void.

(pour la petite histoire, je suis toujours à l'aide d'un vieux compilateur avec peu de tr1 support, donc je n'ai que bind et function expérience de l'utilisation de boost, peut-être que les choses ont changé un peu pour tr1...)

OriginalL'auteur Pieter