Signaux/slots c++0x

Présentation
Cette bibliothèque propose un système de signaux/slots, utilisable avec c++1x (en particulier avec son support dans gcc 4.5).
Toute documentation est en anglais, dans les headers.
Téléchargement
Compatibilité
Linux Mac Windows
0  0 
Téléchargé 1 fois Voir les 2 commentaires
Détails
Catégories : Codes sources C++
Avatar de NoIdea
Membre actif
Voir tous les téléchargements de l'auteur
Licence : Non renseignée
Date de mise en ligne : 8 décembre 2010




Avatar de poukill poukill - Membre chevronné https://www.developpez.com
le 08/12/2010 à 8:27
Question béotienne : Qu'apporte ton code par rapport à boost.Signals2 ?
Avatar de NoIdea NoIdea - Membre actif https://www.developpez.com
le 08/12/2010 à 13:25
Très bonne question. Cette bibliothèque ne fonctionne pas du tout sur le même principe :

Avec boost.signals (il me semble que boost.signals2 rajoute juste le thread-safe), tu es obligé un objet d'un type très particulier :
Tu ne peux faire signal mysignal; et connecter tout et n'importe quoi : il y a un type template ce qui empêche la mise dans un conteneur par exemple.

Avec mon système, on déclare un objet comme "pouvant recevoir des connections" en l'héritant de Emittable. Le template à Emittable ne sert qu'à pouvoir appliquer le CRTP.

Par exemple, si je prend l'exemple du tutoriel de boost, on peut avoir des signaux pour "OnClick". Ce qui signifie que la classe doit prévoir les évènements qui peuvent être émis. Avec mon système, on hérite de Emittable<ce qu'on veut> et lors du constructeur on fait Connect("ClickEvent", ma_fonction);

Puisqu'il semblerait que dans la "présentation" mon exemple ait été coupé, je vais le reposter ici :

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <iostream>
#include <EventSystem/EventSystem.hpp>
#include <ctime>

using namespace std::placeholders;

class Exemple : public ES::Emittable<Exemple>
{
    private :
        std::map<int, std::string> Commentaires;
    public :
        void ShowCommentaire(std::clock_t deb, std::clock_t fin)
        {
            int sec=(fin-deb)/CLOCKS_PER_SEC;
            auto it=Commentaires.find(sec);
            if(it==Commentaires.end())
                std::cout<<"\nVous etes lamentablement long a taper au clavier";
            else
                std::cout<<"\n"<<it->second;
        }
        Exemple() : Commentaires{std::make_pair(0,"Remarquable"),std::make_pair(1,"Remarquable"),std::make_pair(2,"Remarquable"),
        std::make_pair(3,"Tres Bien"), std::make_pair(4,"Tres Bien"),std::make_pair(5,"Tres Bien"),
        std::make_pair(6,"Bien"),std::make_pair(7,"Bien"),std::make_pair(8,"Bien"),
        std::make_pair(9,"Moyen"),std::make_pair(10,"Moyen"),std::make_pair(11,"Moyen"),
        std::make_pair(12,"Mauvais"),std::make_pair(13,"Mauvais"),std::make_pair(14,"Mauvais")}
        {}
};

void ShowTime(std::clock_t deb, std::clock_t timefin)
{
    std::cout<<"\nVous avez mis "<<static_cast<float>(timefin-deb)/CLOCKS_PER_SEC<<" secondes a taper votre chaine de caractere";
}

int main()
{
    unsigned deb=clock();
    std::string EstValide;
    Exemple e;
    e.Connect("Fini",ES::Event<std::clock_t>::MakeCallback(ShowTime, deb, _1));
    e.Connect("Fini",ES::Event<std::clock_t>::MakeCallback(ES::MakeMember(e, &Exemple::ShowCommentaire), deb, _1));
    do
    {
        std::cout<<"Ce programme vous affichera le temps mis a taper la chaine de caractere avec un systeme evenementiel. Veuillez taper \"Bonjour Bienvenu dans un nouveau monde.\".\n";
        getline(std::cin, EstValide);
        std::cout<<"\n\n";
        std::cin.clear();
    }while(EstValide!="Bonjour Bienvenu dans un nouveau monde.");
    std::cout<<"\nOK Vous avez reussi a taper la chaine.";
    e.Emit("Fini", ES::Event<std::clock_t>(clock()));
    return 0;
}
De plus, comment gérer dynamiquement le nombre de différents signaux (je ne dis pas que c'est impossible, je dis juste que sa ne me parait pas évident) ?

D'autre part, je n'utilise aucune fonction virtuelle. Malheureusement, sa me semble pas très plausible et j'aimerais savoir si les lambda peuvent parfois agir en tant que fonction virtuelle. Si oui, est-ce le cas dans cette bibliothèque ?

 
Developpez.com décline toute responsabilité quant à l'utilisation des différents éléments téléchargés.