creation class matrice, T** contre vector<vector<T> >

Version imprimable

Salut,
il y a un moi je voulais tester une class matrice avec des template histoire de faire un class qui peut travailler avec des int double et complex<..>. Seulement je l'ai implémenté du style:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
template<class T>
class matrice
{
private:
    size_t nl;
    size_t nc;
    T** tab;
 
public:
    //Constructors
    matrice();
 
    matrice(const size_t& li,const size_t& co,const T& val=T());
    matrice(const matrice<T>& mat);
 
    template<class U>
    matrice(const matrice<U>& mat);
 
    //Destructor
    ~matrice(){ Reset();}
 
    // Operators
    matrice<T>& matrice<T>::operator=(const matrice<T>& mat);
    matrice<T>& matrice<T>::operator=(const T& val);
    template<class U>
    matrice<T>& operator=(const matrice<U>& mat);
    T& operator()(const size_t& i, const size_t& j);
    const T& operator()(const size_t& i,const size_t& j) const;
 
    matrice<T>& operator+=(const matrice<T>& mat);
    matrice<T>& operator-=(const matrice<T>& mat);
    matrice<T>& operator*=(const matrice<T>& mat);
 
    matrice<T>& operator+=(const T& val);
    matrice<T>& operator-=(const T& val);
    matrice<T>& operator*=(const T& val);
 
    template<class U>
    friend std::ostream &operator<<(std::ostream &out,matrice<U> &mat);
 
    //Methods
    inline const size_t& Line() const{return nl;}
    inline const size_t& Column() const{return nc;}
 
    bool Allocate(const size_t& li,const size_t& co);
    void Reset();
 
    template<class U>
    void Initialize(const U& val);
 
    matrice<T>& Transpose();
 
    void Print(std::ostream& out) const;
};

Je me demandait si utiliser un vector<vector<T> > serait plus ou moins efficace que d'utiliser un T**?

Certainement que cette question a été posée mais je vois pas de référence là dessus.

Merci

15/02/2008, 12h46
poukill
Oh oui, le sujet des matrices a été très largement traité dans ce forum.

En deux mots :
1. T * data; suffit. L'accès peut être donné par i + n * j.
2. Les vector de vector sont effectivement à éviter, sauf si tu as des réallocations fréquentes.
Cherche dans le forum, tu trouveras ton bonheur !
15/02/2008, 12h46
ac_wingless

Si vous pouvez utiliser Boost, vous devriez évaluer leur travail sur ce sujet. Pour ceux qui ne connaissent pas, Boost est une librairie de qualité exceptionnelle.
15/02/2008, 13h02
r0d

Sur le sujet, voir ce lien, à mon avis indispensable:
http://jlecomte.ifrance.com/c++/c++-...oading-fr.html

Citation:

Envoyé par poukill

Oh oui, le sujet des matrices a été très largement traité dans ce forum.

En deux mots :

T * data;[/I] suffit. L'accès peut être donné par i + n * j.
Les vector de vector sont effectivement à éviter, sauf si tu as des réallocations fréquentes.

Cherche dans le forum, tu trouveras ton bonheur !

ok merci. En fait je force la contiguïté de de mon tableau T** en fasant un truc du genre
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 template<class T> bool matrice<T>::Allocate(const size_t& li, const size_t& co) { if(tab!=NULL) Reset(); nl=li; nc=co; tab=new T*[nl]; if(tab==NULL) return false; tab[0]=new T[nl*nc]; if(tab[0]==NULL) { delete[] tab; tab=NULL; return false; } for(size_t i=1;i<nl;i++) tab[i]=tab[i-1]+nc; Initialize(T()); return true; }
Apres je peux utiliser dessus une notation tab[i][j]; que j'appel dans mon oprateur ()

Citation:

Envoyé par ac_wingless

Si vous pouvez utiliser Boost, vous devriez évaluer leur travail sur ce sujet. Pour ceux qui ne connaissent pas, Boost est une librairie de qualité exceptionnelle.

je suis tombé dessus en effet. Mais ici le but de la manoeuvre n'est pas d'utiliser cette class, mais uniquement pédagogique, car je suis en train de passer du C au C++. A l'avenir si je dois utiliser ce genre de class matrice je passerai par boost ;) meme si il me reste encore des choses à apprendre avant de passer à boost

15/02/2008, 13h13
poukill

Avec un T * data, je te propose mieux comme accès : tab(i,j) ... ;)
Et c'est plus performant.
15/02/2008, 13h16
reptils

Citation:

Envoyé par r0d

Sur le sujet, voir ce lien, à mon avis indispensable:
http://jlecomte.ifrance.com/c++/c++-...oading-fr.html

Merci je jetterai un oeil dans la journée ;)

Edit: j'ai jetté un oeil et c'est interessant. En gros je me suis pas trop votré dans ma façon de concevoir ma class.

Citation:

Envoyé par poukill

Avec un T * data, je te propose mieux comme accès : tab(i,j) ... ;)
Et c'est plus performant.

developpe 8O je vois pas ce que ça apporterai de mieux, dans la mesure où je fais un masquage du T* data
15/02/2008, 16h13
poukill

Le mieux pour les performances c'est de faire un benchmark avec 2 implémentations différentes...
Regarde ce post, tu y trouveras peut-être quelques tuyaux. ;) Je pense pas que l'accès [][] soit le plus rapide (mais je peux me tromper :) )
15/02/2008, 19h12
JolyLoic

Un vector<vector<T> > (équivalent à un T**) n'est probablement pas une solution très attirante, mais par contre, utiliser un vector<T> (équivalent au T*) et indexer par i + n*j me semble une solution intéressante.

Salut,

Le gros problème des pointeurs de pointeurs est toujours... celui de risquer d'oublier un déréférencement :P

Et, juste pour rire, un code qui, bien que ne supportant pas les pointeurs, pourrait te donner des idées ;) (mais un trait de politique devrait pouvoir suffir à ton bonheur ;))

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
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
#include <iostream>
#include <iomanip>
#include <vector>
 
template <class T>
class Matrice
{
        /* ce typedef n'est là que pour me faciliter l'écriture :p*/
        typedef typename std::vector<T> mattype;
    public:
        /* et ceux-ci sont présents pour pouvoir utiliser les itérateurs
         * habituels
         */
        typedef typename mattype::iterator iterator;
        typedef typename mattype::const_iterator const_iterator;
        class Line
        {
                friend class Matrice;
            private:
                /* on ne peut pas créer nous meme une ligne*/
                Line(const std::vector<T>& line):line(line),cells(line.size()){}
            public:
                /* mais on doit pouvoir la détruire, et les opérateur de copie et
                 * d'affectation peuvent être accessibles ;)
                 * (sauf si tu prévois de créer un trait de politique pour les
                 * pointeurs )
                 */
                ~Line(){}
                size_t size() const{return cells;}
                T& operator[](size_t ind)
                {
                    return line[ind];
                }
            private:
                std::vector<T> line;
                size_t cells;
 
        };
        Matrice(size_t lines=0, size_t cols=0):lines(lines), cols(cols),
                mat(lines*cols)
        {}
        ~Matrice(){}
        void resize(size_t nlines, size_t ncols)
        {
            lines=nlines;
            cols=ncols;
            mat.resize(lines*cols);
        }
        size_t lineCount() const{return lines;}
        size_t colCount() const {return cols;}
        iterator begin(){return mat.begin();}
        iterator end(){return mat.end();}
        void put(const T& value, size_t line, size_t col)
        {
            mat[line*cols+col]=value;
        }
        T& getCell(size_t line, size_t col)
        {
            return mat[line*cols+col];
        }
        const T& getCell(size_t line, size_t col) const
        {
            return mat[line*cols+col];
        }
        Line GetLine(size_t num) const
        {
            --num;
            Line ret(mattype(mat.begin()+(num*cols),mat.begin()+(num*cols)+cols));
            return ret;
        }
        void SetLine(const Line& toset,size_t num)
        {
            --num;
            mat.erase(mat.begin()+(num*cols),mat.begin()+(num*cols)+cols);
            mat.insert(mat.begin()+num*cols,toset.line.begin(),toset.line.end());
        }
    private:
        size_t lines;
        size_t cols;
        mattype mat;
};
using namespace std;
int main()
{
    Matrice<int> mat;
    mat.resize(10,10);
    /* les deux lignes ci-dessus auraient très bien pu être remplacées par une
     * seule:
     Matrice<int> mat(10,10);
     */
    cout<< "Initialisons la matrice"<<endl;
    for(size_t i=0;i<10;i++)
        for(size_t j=0;j<10;j++)
            mat.put(i*10+j,i,j);
    cout<<"elle fonctionne avec les itérateurs"<<endl;
    for(Matrice<int>::iterator it=mat.begin();it!=mat.end();it++)
        cout<<setw(4)<<(*it);
    cout<<"... et avec la méthode getCell()"<<endl;
    for(size_t i=0;i<mat.lineCount();i++)
    {
        for(size_t j=0;j<mat.colCount();j++)
            cout<<setw(4)<<mat.getCell(i,j);
        cout<<endl;
    }
    cout<<"on peut récupérer la troisième ligne pour voir"<<endl;
    Matrice<int>::Line line=mat.GetLine(3);
    for(size_t i=0;i<line.size();i++)
        cout<<setw(4)<<line[i];
    cout<<endl<<"la modifier"<<endl;
    for(size_t i=0;i<line.size();i++)
    {
        line[i]=line[i]*2;
    }
    cout<<"et la replacer dans la matrice"<<endl;
    mat.SetLine(line,3);
    for(size_t i=0;i<mat.lineCount();i++)
    {
        for(size_t j=0;j<mat.colCount();j++)
            cout<<setw(4)<<mat.getCell(i,j);
        cout<<endl;
    }
    cout<<"le cinquième element de la sixieme ligne est "
        <<mat.GetLine(6)[5]<<endl;
    return 0;
}