Partager via


Comment : fournir des fonctions de travail aux classes call et transformer

Cette rubrique illustre plusieurs méthodes permettant de fournir des fonctions de travail aux classes Concurrency::call et Concurrency::transformer.

Le premier exemple montre comment passer une expression lambda à un objet call. Le deuxième exemple montre comment passer un objet de fonction à un objet call. Le troisième exemple montre comment lier une méthode de classe à un objet call.

À titre d'illustration, chaque exemple dans cette rubrique utilise la classe call. Pour obtenir un exemple qui utilise la classe transformer, consultez Comment : utiliser la classe transformer dans un pipeline de données.

Exemple

L'exemple suivant illustre une manière courante d'utiliser la classe call. Cet exemple passe une fonction lambda au constructeur call.

// call-lambda.cpp
// compile with: /EHsc
#include <agents.h>
#include <iostream>

using namespace Concurrency;
using namespace std;

int wmain()
{
   // Stores the result of the computation.
   single_assignment<int> result;

   // Pass a lambda function to a call object that computes the square
   // of its input and then sends the result to the message buffer.
   call<int> c([&](int n) {
      send(result, n * n);
   });

   // Send a message to the call object and print the result.
   send(c, 13);
   wcout << L"13 squared is " << receive(result) << L'.' << endl;
}

Cet exemple génère la sortie suivante :

13 squared is 169.

L'exemple suivant ressemble au précédent, mais il utilise la classe call avec un objet de fonction (functor).

// call-functor.cpp
// compile with: /EHsc
#include <agents.h>
#include <iostream>

using namespace Concurrency;
using namespace std;

// Functor class that computes the square of its input.
class square
{
public:
   explicit square(ITarget<int>& target)
      : _target(target)
   {
   }

   // Function call operator for the functor class.
   void operator()(int n)
   {
      send(_target, n * n);
   }

private:
   ITarget<int>& _target;
};

int wmain()
{
   // Stores the result of the computation.
   single_assignment<int> result;

   // Pass a function object to the call constructor.
   square s(result);
   call<int> c(s);

   // Send a message to the call object and print the result.
   send(c, 13);
   wcout << L"13 squared is " << receive(result) << L'.' << endl;
}

L'exemple suivant ressemble au précédent, mais il utilise les fonctions std::bind1st et std::mem_fun pour lier un objet call à une méthode de classe.

Utilisez cette technique si vous devez lier un objet call ou transformer à une méthode de classe spécifique au lieu de l'opérateur d'appel de fonction, operator().

// call-method.cpp
// compile with: /EHsc
#include <agents.h>
#include <functional>
#include <iostream>

using namespace Concurrency;
using namespace std;

// Class that computes the square of its input.
class square
{
public:
   explicit square(ITarget<int>& target)
      : _target(target)
   {
   }

   // Method that computes the square of its input.
   void square_value(int n)
   {
      send(_target, n * n);
   }

private:
   ITarget<int>& _target;
};

int wmain()
{
   // Stores the result of the computation.
   single_assignment<int> result;

   // Bind a class method to a call object.
   square s(result);
   call<int> c(bind1st(mem_fun(&square::square_value), &s));

   // Send a message to the call object and print the result.
   send(c, 13);
   wcout << L"13 squared is " << receive(result) << L'.' << endl;
}

Vous pouvez également assigner le résultat de la fonction bind1st à un objet std::function ou utiliser le mot clé auto, comme indiqué dans l'exemple suivant.

// Assign to a function object.
function<void(int)> f1 = bind1st(mem_fun(&square::square_value), &s);
call<int> c1(f1);

// Alternatively, use the auto keyword to have the compiler deduce the type.
auto f2 = bind1st(mem_fun(&square::square_value), &s);
call<int> c2(f2);

Compilation du code

Copiez l'exemple de code et collez-le dans un projet Visual Studio, ou collez-le dans un fichier nommé call.cpp puis exécutez la commande suivante dans une fenêtre d'invite de commandes Visual Studio 2010.

cl.exe /EHsc call.cpp

Voir aussi

Tâches

Comment : utiliser la classe transformer dans un pipeline de données

Référence

call, classe

Classe transformer

Concepts

Bibliothèque d'agents asynchrones

Blocs de messages asynchrones