Matrice de vecteurs de points 2D

Salut la communauté des c++i1,
je suis à la recherche d'outils adéquat pour pouvoir manipuler mes données.

Je souhaite créer une matrice de taille fixe contenant des vecteurs de points.
Ces vecteurs sont alloués dynamiquement.

Je recherche des outils d'une lib ou une syntaxe simplifié qui me permettent de parcourir et stocker des éléments.

Une syntaxe du type :

Matrice <vector<point2D<double > > > maMatrice[200][200];

Je sais que cette syntaxe ne convient pas. Je serais intéressé si vous avez des solutions à m'apporter. :?

Pour les matrices :
uBlas (boost) ou blitz++ (dédié aux matrices).

J'ai regardé du coté de ublast mais je n'y ai pas vu de structures qui me conviennent. Je pense qu'il s'agit davantage d'une librairie adéquat en terme de calcul matriciel. Ma recherche parait assez particulière car je ne souhaite pas faire de calcul mais uniquement du parcours et du stockage. J'en suis à mes débuts en C++ donc je vous remercie pour l'aide que vous pourrez m'apporter.

Salut, et bienvenue sur le forum.

Si ta matrice est carrée, tu peux toujours considérer le fait que, pour créer une matrice utilisant X lignes et Y colonnes, il "suffit" de gérer un tableau composé d'une seule dimension contenant... X*Y éléments.

Pour accéder à la ligne x colonne y, il "suffit" alors d'accéder à l'élément x*X+y ;)

Cela implique que tu pourrais envisager sereinement une classe proche de

Code:

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
class Matrix
{
    public:
        Matrix(size_t lines, size_t cols):lines(lines),cols(cols)
        {
            tab.reserve(lines*cols);
        }
        Point2D<float>& elementAt(size_t l, size_t l)
        {
            /* on peut envisager des vérifications */
            if(l>=lines)
                throw LinesOverflow();
            if(c>=cols)
                throw LinesOverflow();
            return tab[l.lines+c];
        }
        void setElement(size_t l, size_t c, Point2D<float> const& p)
        {
            /* on peut envisager des vérifications */
            if(l>=lines)
                throw LinesOverflow();
            if(c>=cols)
                throw LinesOverflow();
            /* on pourrait envisager de vérifier que l'élément à
             * définir n'est pas encore défini
             */
            tab[l*lines+c] = p;
        }
    private:
        std::vector<Point2D<float> > tab;
};

Si tu veux quelque chose de générique, pour permettre l'utilisation de point2D manipulant différents types, tu peux aussi la généraliser sous la forme de

Code:

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
 
template <typename T>
class Matrix
{
    public:
        typedef T type;
        Matrix(size_t lines, size_t cols):lines(lines),cols(cols)
        {
            tab.reserve(lines*cols);
        }
        type& elementAt(size_t l, size_t l)
        {
            /* on peut envisager des vérifications */
            if(l>=lines)
                throw LinesOverflow();
            if(c>=cols)
                throw LinesOverflow();
            return tab[l.lines+c];
        }
        void setElement(size_t l, size_t c, type const& p)
        {
            /* on peut envisager des vérifications */
            if(l>=lines)
                throw LinesOverflow();
            if(c>=cols)
                throw LinesOverflow();
            /* on pourrait envisager de vérifier que l'élément à
             * définir n'est pas encore défini
             */
            tab[l*lines+c] = p;
        }
    private:
        std::vector<type > tab;
};

[EDIT]Pour que ces deux classes fonctionnent, il faut veiller à ce que le type à contenir (Point2D ou T, selon l'objectif) soit au minimum défaut consstructible, et, par sécurité, copiable et assignable ;)