Tuple et machine état

**Lintel-oo** · 27/12/2012, 13h58

Bonjour à vous

Je viens de penser à mettre en forme une espèce de machine état.
Pour cela j'utilise une classe template de base : une sorte de cellule de base pour la machine état :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
template <typename T>
class CellStateMachine
{
    public:
        CellStateMachine(T param, boost::shared_ptr<std::list<boost::function<void (T)> > > listFunctions = boost::shared_ptr<std::list<boost::function<void (T)> > >());
        CellStateMachine(const CellStateMachine<T> &cpy);
 
        void setParam(T param);
        T getParam() const;
 
        void setListFunctionToCall(boost::shared_ptr<std::list<boost::function<void (T)> > > listFunctions);
        const boost::shared_ptr<std::list<boost::function<void (T)> > > getListFunctionsToCall() const;
 
    private:
        typedef boost::function<void (T)> func;
        T m_param;
        boost::shared_ptr<std::list<boost::function<void (T)> > > m_functionsToCall;
};

Ensuite je regroupe ces cellules dans un tuple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
template <unsigned int Count, typename ... Args>
class SuperCellStateMachine
{};
 
template <typename Head>
class SuperCellStateMachine<0,Head>
{
    public:
        SuperCellStateMachine(boost::shared_ptr<CellStateMachine<Head> > &cell) :
            m_cell(cell)
        {}
 
        boost::shared_ptr<CellStateMachine<Head> > m_cell;
};
 
template <unsigned int Count, typename Head, typename ... Args>
class SuperCellStateMachine<Count,Head,Args...>
{
    public:
        SuperCellStateMachine(boost::shared_ptr<SuperCellStateMachine<Count-1,Args...> > &superCell, boost::shared_ptr<CellStateMachine<Head> > &cell) :
            m_superCell(superCell),
            m_cell(cell)
        {}
 
        boost::shared_ptr<SuperCellStateMachine<Count-1,Args...> > m_superCell;
        boost::shared_ptr<CellStateMachine<Head> > m_cell;
};

Le problème est que je dois arriver à obtenir facilement chaque élément du tuple sans perte de temps excessive. En plus, vu la manière dont j'ai codé ça, je me suis rendu compte que ce n'était pas très pratique vu qu'il faut à chaque fois créer un pointeur sur une cellule, puis un pointeur sur une supercellule en utilisant le pointeur précédent, et continuer ainsi, en escalier, avec toujours plus de pointeurs et de template dans les supercellules créées.

J'ai donc 2 questions : comment avec une structure similaire parvenir à accéder à chaque élément du tuple de manière rapide à la manière d'un get<N> de boost::tuple et comment optimiser ce que j'ai fait ou le remodeler de manière à disposer de quelque chose de simple à initialiser et à utiliser ?

**koala01** · 27/12/2012, 14h15

Salut,

Pourquoi se faire du mal inutilement...

As tu jeté un oeil à boost, il y a deux bibliothèques de machines à état, dont l'une bien aboutie me semble-t-il

**Lintel-oo** · 27/12/2012, 14h40

Merci du tuyau

je vais voir cela de suite

Edit : Oui ça m'a l'air d'être ça, enfin il faudra déjà que je comprenne comment ça fonctionne vu le nombre de chose qu'il semble être possible de faire. Surtout que le tutoriel est en anglais et que sur un "sujet" assez compliqué c'est jamais trop facile quand on a pas l'habitude ^^

**Lintel-oo** · 28/12/2012, 19h16

Quelqu'un pourrait-il m'expliquer pourquoi lorsque je déclare (toujours à partir du code précédent) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
CellStateMachine<float>* c1 = new CellStateMachine<float>(4.236);
boost::shared_ptr<CellStateMachine<float> > b1(c1);
    SuperCellStateMachine<0,float>* s1 = new SuperCellStateMachine<0,float>(b1);

J'ai ce message d'erreur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

error: use of deleted function 'boost::shared_ptr<CellStateMachine<float> >::shared_ptr(const boost::shared_ptr<CellStateMachine<float> >&)'

**Flob90** · 28/12/2012, 20h16

Bonsoir,

Ça compile chez moi (on a pas les implémentation de tout les constructeurs, donc je les ai laissé vides).

Tu pourrais donner un code complet minimal qui donne le même message ? (ie tu prends ton projet, tu le copies, tu enlèves tout ce qui sert à rien, tu mets tout dans un seul fichier, et tu copies le contenu sur le forum) Ça permettra de te donner une réponse vraiment appropriée.

Par contre, pourquoi utiliser la syntaxe C++11 mais boost pour les shared_ptr/function ? En général si le compilateur supporte les variadics, la bibliothèque standard associée aura shared_ptr/function dans std.

Si ta structure est similaire à un tuple, pourquoi ne pas utiliser un tuple justement (std::tuple) ?

**Lintel-oo** · 28/12/2012, 20h28

Oui je posterai bientôt un exemple complet de code.

Pour ce qui est du tuple je ne peux pas utiliser la classe tuple de boost (ou de std) puisque justement je ne veux pas avoir un tuple contenant des types divers mais un tuple contenant des CellStateMachine de type divers donc il faudrait découper le template variadic au dessus d'une SuperCellStateMachine au niveau de chacun des paramètres et ça la classe tuple de boost ne le fait pas (ou alors dîtes moi comment faire en l'utilisant).

Edit : Voici le code :

main.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
#include "supercellstatemachine.hpp"
 
int main()
{   
CellStateMachine<float>* c1 = new CellStateMachine<float>(4.236);
    CellStateMachine<std::vector<int> >* c2 = new  CellStateMachine<std::vector<int> >(std::vector<int>({0,4,5,8,9,6,3}));
    CellStateMachine<int> c3(4);
 
    boost::shared_ptr<CellStateMachine<float> > b1(c1);
    SuperCellStateMachine<0,float>* s1 = new SuperCellStateMachine<0,float>(b1);
    boost::shared_ptr<CellStateMachine<std::vector<int> > > b2(c2);
    boost::shared_ptr<SuperCellStateMachine<0,float> > bs1(s1);
    SuperCellStateMachine<1,std::vector<int>,float> s2(bs1,b2);
 
    return 0;
}

supercellstatemachine.hpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#ifndef SUPERCELLMACHINE_HPP_INCLUDED
#define SUPERCELLMACHINE_HPP_INCLUDED
 
 
#include "cellstatemachine.hpp"
 
 
template <unsigned int Count, typename ... Args>
class SuperCellStateMachine
{};
 
template <typename Head>
class SuperCellStateMachine<0,Head>
{
    public:
        SuperCellStateMachine(boost::shared_ptr<CellStateMachine<Head> > &cell) :
            m_cell(cell)
        {}
 
        boost::shared_ptr<CellStateMachine<Head> > m_cell;
};
 
template <unsigned int Count, typename Head, typename ... Args>
class SuperCellStateMachine<Count,Head,Args...>
{
    public:
        SuperCellStateMachine(boost::shared_ptr<SuperCellStateMachine<Count-1,Args...> > &superCell, boost::shared_ptr<CellStateMachine<Head> > &cell) :
            m_superCell(superCell),
            m_cell(cell)
        {}
 
        boost::shared_ptr<SuperCellStateMachine<Count-1,Args...> > m_superCell;
        boost::shared_ptr<CellStateMachine<Head> > m_cell;
};
 
 
#endif

cellstatemachine.hpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#ifndef CELLSTATEMACHINE_HPP_INCLUDED
#define CELLSTATEMACHINE_HPP_INCLUDED
 
 
#include <list>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
 
 
template <typename T>
class CellStateMachine
{
    public:
        CellStateMachine(T param, boost::shared_ptr<std::list<boost::function<void (T)> > > listFunctions = boost::shared_ptr<std::list<boost::function<void (T)> > >());
        CellStateMachine(const CellStateMachine<T> &cpy);
 
        void setParam(T param);
        T getParam() const;
 
        void setListFunctionToCall(boost::shared_ptr<std::list<boost::function<void (T)> > > listFunctions);
        const boost::shared_ptr<std::list<boost::function<void (T)> > > getListFunctionsToCall() const;
 
    private:
        typedef boost::function<void (T)> func;
        T m_param;
        boost::shared_ptr<std::list<boost::function<void (T)> > > m_functionsToCall;
};
 
template <typename T>
CellStateMachine<T>::CellStateMachine(T param, boost::shared_ptr<std::list<boost::function<void (T)> > > listFunctions) :
        m_param(param)
{
    if(listFunctions)
        m_functionsToCall = listFunctions;
}
 
template <typename T>
CellStateMachine<T>::CellStateMachine(const CellStateMachine<T> &cpy) :
        m_param(cpy.getParam()),
        m_functionsToCall(cpy.getListFunctionsToCall())
{}
 
template <typename T>
void CellStateMachine<T>::setParam(T param)
{
    m_param = param;
    for(typename std::list<func>::iterator it = m_functionsToCall.begin(); it!=m_functionsToCall.end(); it++)
        if(*it)
            (*it)(m_param);
}
 
template <typename T>
T CellStateMachine<T>::getParam() const
{
    return m_param;
}
 
template <typename T>
void CellStateMachine<T>::setListFunctionToCall(boost::shared_ptr<std::list<boost::function<void (T)> > > listFunctions)
{
    if(listFunctions)
        m_functionsToCall = listFunctions;
}
 
template <typename T>
const boost::shared_ptr<std::list<boost::function<void (T)> > > CellStateMachine<T>::getListFunctionsToCall() const
{
    return m_functionsToCall;
}
 
#endif

Tuple et machine état

Langage C++

Vue hybride

Discussions similaires

Partager

Partager