Quel est le mécanisme événementiel des fonctions C++ en programmation concurrente ?

Le mécanisme événementiel de la programmation simultanée répond aux événements externes en exécutant des fonctions de rappel lorsque des événements se produisent. En C++, les mécanismes basés sur les événements peuvent être implémentés à l'aide de pointeurs de fonction : les pointeurs de fonction peuvent enregistrer des fonctions de rappel à exécuter lorsque des événements se produisent. Les expressions Lambda peuvent également implémenter des rappels d'événements, permettant la création d'objets fonction anonymes. Le cas pratique utilise des pointeurs de fonction pour implémenter des événements de clic sur un bouton de l'interface graphique, en appelant la fonction de rappel et en imprimant des messages lorsque l'événement se produit.

Mécanisme événementiel des fonctions C++ dans la programmation simultanée

Introduction

L'événementiel est un paradigme de programmation simultanée dans lequel des threads ou des processus effectuent des opérations spécifiques en réponse à des événements externes. En C++, les mécanismes événementiels sont généralement implémentés via l'utilisation de pointeurs de fonction ou d'expressions lambda.

Implémentation d'événements à l'aide de pointeurs de fonction

Un pointeur de fonction est un pointeur vers une fonction qui vous permet de passer une fonction en tant que paramètre à une autre fonction. Dans la programmation pilotée par événements, vous utilisez des pointeurs de fonction pour enregistrer les fonctions de rappel qui seront exécutées lorsque des événements spécifiques se produisent.

void RegisterEventCallback(const std::function<void()>& callback) {
  // 将 callback 添加到回调函数列表
}

RegisterEventCallback([]() {
  std::cout << "事件发生了！" << std::endl;
});

Dans cet exemple, la fonction RegisterEventCallback accepte comme argument un pointeur de fonction qui pointe vers une fonction de rappel qui est exécutée lorsque l'événement se produit.

Utilisez des expressions lambda pour implémenter des événements

Les expressions lambda vous permettent de créer un objet fonction anonyme sans définir explicitement le nom de la fonction. Ils peuvent être utilisés avec des pointeurs de fonction pour implémenter des rappels d'événements.

RegisterEventCallback([] {
  std::cout << "事件发生了！" << std::endl;
});

Cas pratique

Voici un exemple simple d'implémentation d'une application GUI événementielle en C++ à l'aide de pointeurs de fonction :

#include <iostream>
#include <vector>
#include <memory>

class Button {
public:
  using ButtonCallback = std::function<void(Button*)>;

  Button(const std::string& name)
    : name_(name) {}

  void Click() {
    for (const auto& callback : callbacks_) {
      callback(this);
    }
  }

  void AddClickCallback(const ButtonCallback& callback) {
    callbacks_.push_back(callback);
  }

private:
  std::string name_;
  std::vector<ButtonCallback> callbacks_;
};

class GUI {
public:
  GUI() {
    // 创建两个按钮
    buttons_.push_back(std::make_unique<Button>("Button 1"));
    buttons_.push_back(std::make_unique<Button>("Button 2"));
  }

  void Run() {
    // 注册按钮点击回调
    buttons_[0]->AddClickCallback([](Button* btn) {
      std::cout << "Button " << btn->GetName() << " clicked!" << std::endl;
    });
    buttons_[1]->AddClickCallback([](Button* btn) {
      std::cout << "Button " << btn->GetName() << " clicked!" << std::endl;
    });

    // 模拟按钮点击事件
    buttons_[0]->Click();
    buttons_[1]->Click();
  }

private:
  std::vector<std::unique_ptr<Button>> buttons_;
};

int main() {
  GUI gui;
  gui.Run();
  return 0;
}

Ce programme crée une interface graphique avec deux boutons. Lorsqu'un bouton est cliqué, la fonction de rappel associée à ce bouton est appelée et un message est imprimé dans la console.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!