Discussion :

[El Charpi]

Salut à tous,
J'aurai besoin qu'un oeil neuf se penche sur mon problème, parce que je ne comprends vraiment pas d'où il vient...

Voici quelques structures de données :

Code :

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

1
2
3
typedef std::pair<int, bool> activable_node;
typedef std::vector<activable_node> activable_nuplet;
typedef std::vector<activable_nuplet> activable_nuplet_pool;

Et voici un objet :

Code :

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

std::vector<activable_nuplet_pool> childs_pools;

Normalement, childs_pools est un vecteur de vecteur de vecteur de paires.
Donc childs_pools[i] est un activable_nuplet_pool,
childs_pools[i][j] un activable_nuplet,
childs_pools[i][j][k] un activable_node.

Eh bien non.
J'apelle cette fonction :

Code :

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

childs_pools[i+1][k][y].size()

Et le compilo me retourne la remarque suivante :

erreur: ‘struct std::pair<int, bool>’ has no member named ‘size’

WTF ?

Quand j'essaie d'utiliser childs_pools[i+1][k][y][b].first, il tire encore plus la tête selon quoi l'opérateur [] n'est pas défini pour les paires.

Bref, y'a une couille dans le potage, oui, mais où est-elle ?

Tout ma gratitude à celui qui détecte où ais-je fait mon erreur...

Merci d'avance,
El Charpi.

[Lavock]

typedef std::pair<int, bool> activable_node;
...
childs_pools[i][j][k] un activable_node.

Je vois pas de problème. child_pools[i][j][k] est bien de type std::pair<> oO !

[EDIT] Plus clairement : tu appelle 4 fois l'opérateur [] (ou 3 fois puis size). Le résultat est logique.

[koala01]

Salut,

A titre personnel, ne me demande si l'alias de type est réellement la meilleure solution...

Pourquoi ne pas créer des structures ou des classes qui permettraient d'encapsuler correctement les données et de ne fournir que les comportement qui t'intéressent vraiment

[Cheps]

Effectivement un vecteur de vecteurs de vecteurs c'est à mon avis à éviter. Il serait plus simple d'avoir un vecteur à une dimension pour let int et un pour les bool. Tes paires de points seraient alors v1[i] et v2[i]. Utiliser un vecteur à une dimension comme si il y en avait trois n'est pas trop compliqué.

[koala01]

A vrai dire, je pensais carrément à ne pas utiliser la std::pair, mais plutôt une structure proche de

Code :

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

1
2
3
4
5
struct ActivateNode
{
    int key;
    bool state;
};

D'encapsuler un talbeau (ou peut être même plutot un set ) de ActivateNode dans une première classe fournissant les services les plus utiles

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
class ActivateNuplet
{
    public:
        typedef std::vector<ActivateNode>::iterator iterator;
        typedef std::vector<ActivateNode>::const_iterator const_iterator;
        ActivateNuplet(size_t s):tab_(s){}
        void activate(int);
        void deactivate(int);
        void add(int, bool);
        bool isActive(int) const;
        size_t size() const;
        iterator begin(){return tab_.begin();}
        iterator end(){return tab_.end();}
        const_iterator begin() const{return tab_.begin();}
        const_iterator end() const{return tab_.end();}
    private:
        std::vector<ActivateNode> tab_;
};

D'encapsuler cette première classe dans une deuxième fournissant les services les plus utiles:

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
class ActivateNupletPool
{
    public:
        void addNuplet(size_t s=0){tab_.push_back(ActivateNuplet(s));}
        typedef std::vector<ActivateNuplet>::iterator iterator;
        typedef std::vector<ActivateNuplet>::const_iterator const_iterator;
        ActivateNuplet(size_t s):tab_(s){}
        void activate(int nup, int node);
        void deactivate(int nup, int node);
        void add(int nup, int node, bool);
        bool isActive(int nup, int node) const;
        size_t size() const;
        iterator begin(){return tab_.begin();}
        iterator end(){return tab_.end();}
        const_iterator begin() const{return tab_.begin();}
        const_iterator end() const{return tab_.end();}
    private:
        std::vector<ActivateNuplet> tab_;
};

et ainsi de suite...