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

Article
10/12/2023

Cette rubrique illustre plusieurs façons de fournir des fonctions de travail aux classes concurrency ::call et concurrency ::transformer .

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

Pour illustration, chaque exemple de cette rubrique utilise la call classe. Pour obtenir un exemple qui utilise la transformer classe, consultez Guide pratique pour utiliser un transformateur dans un pipeline de données.

Exemple : appeler une classe

L’exemple suivant montre un moyen courant d’utiliser la call classe. Cet exemple transmet une fonction lambda au call constructeur.

// 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 produit la sortie suivante.

13 squared is 169.

Exemple : appeler une classe avec un objet de fonction

L’exemple suivant ressemble à celui précédent, sauf qu’il utilise la call classe avec un objet de fonction (fonctor).

// 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;
}

Exemple : Fonctions pour lier un objet d’appel

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

Utilisez cette technique si vous devez lier un call ou transformer un objet à 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 affecter le résultat de la bind1st fonction à un objet std ::function ou utiliser le auto mot clé, comme illustré 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.

cl.exe /EHsc call.cpp

Voir aussi

Bibliothèque d’agents asynchrones
Blocs de messages asynchrones
Guide pratique pour utiliser la classe transformer dans un pipeline de données
call, classe
transformer, classe

Partager via