Vecteurs de vecteurs de vecteurs

Version imprimable

11/01/2010, 15h21
El Charpi

Vecteurs de vecteurs de vecteurs
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:

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:

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:

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.
11/01/2010, 15h25
Lavock

Citation:

Envoyé par El Charpi

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.
11/01/2010, 17h08
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 :question:
11/01/2010, 20h22
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é.

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

Code:

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

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

Code:

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:

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...