Discussion :

[reptils]

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 :

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

[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 !

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

[r0d]

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

[reptils]

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

En deux mots :

1. T * data;[/I] 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 !

ok merci. En fait je force la contiguïté de de mon tableau T** en fasant un truc du genre

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
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 ()

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

[poukill]

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

[reptils]

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.

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

developpe je vois pas ce que ça apporterai de mieux, dans la mesure où je fais un masquage du T* data

[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 )