Gewusst wie: Bereitstellen von Arbeitsfunktionen für die call- und transformer-Klassen

Artikel
10/12/2023

In diesem Thema werden verschiedene Möglichkeiten zum Bereitstellen von Arbeitsfunktionen für die Parallelitätsklassen::call und concurrency::transformer veranschaulicht.

Im ersten Beispiel wird gezeigt, wie ein Lambdaausdruck an ein call-Objekt übergeben wird. Im zweiten Beispiel wird gezeigt, wie ein Funktionsobjekt an ein call-Objekt übergeben wird. Im dritten Beispiel wird gezeigt, wie eine Klassenmethode an ein call-Objekt gebunden wird.

Zu Illustrationszwecken wird in allen Beispielen dieses Themas die call-Klasse verwendet. Ein Beispiel, das die transformer Klasse verwendet, finden Sie unter How to: Use transformer in a Data Pipeline.

Beispiel: Anrufklasse

Im folgenden Beispiel wird aufgezeigt, wie die call-Klasse häufig verwendet wird. In diesem Beispiel wird eine Lambda-Funktion an den call-Konstruktor übergeben.

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

Folgende Ergebnisse werden zurückgegeben:

13 squared is 169.

Beispiel: Aufrufklasse mit Funktionsobjekt

Das folgende Beispiel ähnelt dem vorherigen mit der Ausnahme, dass die call-Klasse zusammen mit einem Funktionsobjekt (Funktionselement) verwendet wird.

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

Beispiel: Funktionen zum Binden des Aufrufobjekts

Das folgende Beispiel ähnelt dem vorherigen, mit der Ausnahme, dass es die Funktionen "std::bind1st " und "std::mem_fun " verwendet, um ein call Objekt an eine Klassenmethode zu binden.

Verwenden Sie diese Technik anstatt des Funktionsaufrufoperators, call, wenn Sie ein transformer- oder operator()-Objekt an eine bestimmte Klassenmethode binden möchten.

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

Sie können das Ergebnis der bind1st Funktion auch einem std::function-Objekt zuweisen oder das auto Schlüsselwort (keyword) verwenden, wie im folgenden Beispiel gezeigt.

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

Kompilieren des Codes

Kopieren Sie den Beispielcode, fügen Sie ihn in ein Visual Studio-Projekt ein, oder fügen Sie ihn in eine Datei ein, die benannt call.cpp ist, und führen Sie dann den folgenden Befehl in einem Visual Studio-Eingabeaufforderungsfenster aus.

cl.exe /EHsc call.cpp

Siehe auch

Asynchrone Agents Library
Asynchrone Nachrichtenblöcke
Vorgehensweise: Verwenden von transformer in einer Datenpipeline
call-Klasse
transformer-Klasse

Freigeben über