Exemple complet d'utilisation de Boost::Signal pour le C++ concours complet

Je suis conscient du tutoriel boost.org aborder ce:
Boost.org Les Signaux Tutoriel, mais les exemples ne sont pas exhaustifs et quelque peu simplifiée. Les exemples n'ont pas d'afficher les fichiers d'inclusion et de certains articles du code sont un peu vague.

Voici ce que j'ai besoin de:

ClassA soulève de multiples événements/signaux

ClassB souscrit à ces événements (Plusieurs classes peuvent s'abonner)

Dans mon projet j'ai un niveau inférieur gestionnaire de messages de classe qui déclenche des événements à une entreprise de classe qui fait du traitement de ces messages et en informe l'INTERFACE utilisateur (wxFrames). J'ai besoin de savoir comment ces tous peuvent obtenir filaire (quel ordre, qui appelle qui, etc).

InformationsquelleAutor Chris Andrews | 2009-04-20

boost-signals c++

86

Le code ci-dessous est un minimum de travail exemple de ce que vous avez demandé. ClassA émet deux signaux; SigA envoie (et accepte) pas de paramètres, SigB envoie un int. ClassB a deux fonctions qui seront de sortie pour cout lors de chaque fonction est appelée. Dans l'exemple, il existe une instance de ClassA (a) et deux de ClassB (b et b2). main est utilisé pour la connexion et le feu les signaux. Il est intéressant de noter que ClassA et ClassB rien savoir les uns des autres (c'est à dire qu'ils ne sont pas au moment de la compilation lié).
```
#include <boost/signal.hpp>
#include <boost/bind.hpp>
#include <iostream>

using namespace boost;
using namespace std;

struct ClassA
{
    signal<void ()>    SigA;
    signal<void (int)> SigB;
};

struct ClassB
{
    void PrintFoo()      { cout << "Foo" << endl; }
    void PrintInt(int i) { cout << "Bar: " << i << endl; }
};

int main()
{
    ClassA a;
    ClassB b, b2;

    a.SigA.connect(bind(&ClassB::PrintFoo, &b));
    a.SigB.connect(bind(&ClassB::PrintInt, &b,  _1));
    a.SigB.connect(bind(&ClassB::PrintInt, &b2, _1));

    a.SigA();
    a.SigB(4);
}
```
La sortie:
```
Foo 
Bar: 4 
Bar: 4 
```
Par souci de concision, j'ai pris quelques raccourcis que vous ne serait pas l'habitude d'utiliser dans le code de production (en particulier le contrôle d'accès est laxiste et que vous auriez normalement "cacher" votre signal d'inscription derrière une fonction comme dans KeithB exemple).

Il semble que la plupart de la difficulté à boost::signal est de s'habituer à l'utilisation de boost::bind. Il est un peu l'esprit de flexion au premier! Pour une plus délicat exemple, vous pourriez aussi utiliser bind pour raccorder ClassA::SigA avec ClassB::PrintInt même si SigA ne pas émettent un int:
```
a.SigA.connect(bind(&ClassB::PrintInt, &b, 10));
```
Espère que ça aide!
- Est-il possible de surcharger une fonction, et si oui, auriez-vous l'esprit en ajoutant que. s.t. vous avez quelque chose comme PrintNum(int); et PrintNum(float);
- Utiliser une fonction de type (pas sûr du terme exact): (void (*)(int))&PrintNum
InformationsquelleAutor MattyT
11

Voici un exemple à partir de notre base de code. Son été simplifiée, donc je n'ai pas les garanties qu'il compile, mais il devrait être proche. Code secondaire est à votre classe Un, et Slot1 est votre classe B. Nous avons un certain nombre de machines à sous comme cela, chacun qui s'abonne à un autre sous-ensemble de signaux. Les avantages de l'utilisation de ce programme sont que code secondaire ne sait rien au sujet de l'une des machines à sous, et les fentes n'avez pas besoin de faire partie d'une hiérarchie d'héritage, et seulement besoin d'implémenter des fonctionnalités pour les logements qu'ils occupent. Nous nous en servons pour ajouter des fonctionnalités personnalisées dans notre système avec une interface très simple.

Code secondaire.h
```
class Sublocation 
{
public:
  typedef boost::signal<void (Time, Time)> ContactSignal;
  typedef boost::signal<void ()> EndOfSimSignal;

  void endOfSim();
  void addPerson(Time t, Interactor::Ptr i);

  Connection addSignalContact(const ContactSignal::slot_type& slot) const;
  Connection addSignalEndOfSim(const EndOfSimSignal::slot_type& slot) const;    
private:
  mutable ContactSignal fSigContact;
  mutable EndOfSimSignal fSigEndOfSim;
};
```
Code secondaire.C
```
void Sublocation::endOfSim()
{
  fSigEndOfSim();
}

Sublocation::Connection Sublocation::addSignalContact(const ContactSignal::slot_type& slot) const
{
  return fSigContact.connect(slot);
}

Sublocation::Connection Sublocation::addSignalEndOfSim(const EndOfSimSignal::slot_type& slot) const
{
  return fSigEndOfSim.connect(slot);
}

Sublocation::Sublocation()
{
  Slot1* slot1 = new Slot1(*this);
  Slot2* slot2 = new Slot2(*this);
}

void Sublocation::addPerson(Time t, Interactor::Ptr i)
{
  //compute t1
  fSigOnContact(t, t1);
  //...
}
```
Slot1.h
```
class Slot1
{
public:
  Slot1(const Sublocation& subloc);

  void onContact(Time t1, Time t2);
  void onEndOfSim();
private:
  const Sublocation& fSubloc;
};
```
Slot1.C
```
Slot1::Slot1(const Sublocation& subloc)
 : fSubloc(subloc)
{
  subloc.addSignalContact(boost::bind(&Slot1::onContact, this, _1, _2));
  subloc.addSignalEndSim(boost::bind(&Slot1::onEndSim, this));
}


void Slot1::onEndOfSim()
{
  //...
}

void Slot1::onContact(Time lastUpdate, Time t)
{
  //...
}
```
- Bon exemple. Mais je dirais assez fortement que les signaux pas être mutables et addSignalXXX devrait pas être const. Ils font partie de l'interface publique et certainement changer le comportement de code secondaire.
- Je pense que ce point est discutable. Je peux comprendre d'où vous venez. D'autre part, l'ajout d'un logement ne changera code secondaire de l'état directement. Et si la fente veut changer l'état lors de son nom, il doit appeler nonconst fonctions de membre de code secondaire. Si cette question a été soulevée dans une revue de code, j'avais de l'état de mon cas, mais ça ne me dérange pas de faire le changement que vous l'avez suggéré, si tel est le consensus.
- Je peux voir votre argument trop...il serait probablement intéressant de révision du code de la discussion. 🙂
InformationsquelleAutor KeithB
6

Avez-vous regarder boost/libs/signaux/exemple ?
- Merci! ces exemples sont un peu mieux, mais il serait agréable d'avoir un plus grand, plus réaliste, par exemple.
InformationsquelleAutor Éric Malenfant

Boost comme QT fournit sa propre mise en œuvre de signaux et les slots. Voici quelques exemple de sa mise en œuvre.

De signaux et de slots de connexion pour l'espace de noms

Envisager un espace de noms appelé GStreamer

 namespace GStremer
 {
  void init()
  {
  ....
  }
 }

Ici est de savoir comment créer et déclencher le signal

 #include<boost/signal.hpp>

 ...

 boost::signal<void ()> sigInit;
 sigInit.connect(GStreamer::init);
 sigInit(); //trigger the signal

De signaux et de slots de connexion pour une Classe

Envisager une Classe appelée GSTAdaptor avec fonction appelée func1 et func2 avec la suite de la signature

void GSTAdaptor::func1()
 {
 ...
 }

 void GSTAdaptor::func2(int x)
 {
 ...
 }

Ici est de savoir comment créer et déclencher le signal

#include<boost/signal.hpp>
 #include<boost/bind.hpp>

 ...

 GSTAdaptor g;
 boost::signal<void ()> sigFunc1;
 boost::signal<void (int)> sigFunc2;

 sigFunc1.connect(boost::bind(&GSTAdaptor::func1, &g); 
 sigFunc2.connect(boost::bind(&GSTAdaptor::func2, &g, _1));

 sigFunc1();//trigger the signal
 sigFunc2(6);//trigger the signal

InformationsquelleAutor Vihaan Verma

Lors de la compilation de MattyT l'exemple avec les nouveaux boost (f.e. 1.61) puis il donne un avertissement

error: #warning "Boost.Signals is no longer being maintained and is now deprecated. Please switch to Boost.Signals2. To disable this warning message, define BOOST_SIGNALS_NO_DEPRECATION_WARNING."

Donc, soit vous définissez BOOST_SIGNALS_NO_DEPRECATION_WARNING pour supprimer l'avertissement ou vous pouvez facilement passer de coup de pouce.signal2 en modifiant l'exemple en conséquence:

#include <boost/signals2.hpp>
#include <boost/bind.hpp>
#include <iostream>

using namespace boost::signals2;
using namespace std;

InformationsquelleAutor psalong

Vous devez vous connecter pour publier un commentaire.