Tableau dynamique générique 2D..

Bonjour, je voudrais me faire une petite fonction qui permet de créer un tableau dynamique à 2 dimensions de n'importe quel type. J'ai écrit cette fonction :

Code:

---

1 2 3 4 5 6 7 8 9

template <class T> void T_Array2D(T ** _t, int _dim1, int _dim2) { _t = new T * [_dim1]; for (int dim_allouee = 0; dim_allouee < _dim1; ++dim_allouee) { _t[dim_allouee] = new T[_dim2]; } }

---

Je déclare un pointeur :

Code:

---

mlVec3 ** tab;

---

mlVec3 est un type créé par mon tuteur de TPs (il s'agit d'un tableau : double t[3] pour accueillir donc 3 doubles (pour des coordonnées 3D pour OpenGL)).

Et j'appelle ma fonction :

Code:

---

T_Array2D<mlVec3>(tab, _nBP+1, _nBP+1);

---

Mais lorsque, j'utilise ensuite ce tableau tab, je me choppe une erreur de segmentation, je vais voir dans le gdb et je vois que le pointeur est nul (0x0).

Si vous avez une idée...

Je vous remercie de votre réponse.

Ta fonction reçoit et manipule une copie de tab, du coup après son appel ton pointeur reste inchangé. Si tu veux que la fonction manipule directement tab, alors il faut le passer par référence (T**& _t).
Mais le plus propre serait sans doute de le renvoyer :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

template <class T> T ** T_Array2D(int _dim1, int _dim2) { T ** t = new T * [_dim1]; for (int dim_allouee = 0; dim_allouee < _dim1; ++dim_allouee) { t[dim_allouee] = new T[_dim2]; }   return t; }   mlVec3 ** tab = T_Array2D<mlVec3>(_nBP+1, _nBP+1);

---

D'accord, je pensais que comme je passais un pointeur en paramètre, je travaillais directement dessus.
J'ai un ensemble de fonctions imbriquées dans lesquelles je passe en paramètre un même pointeur et celui-ci est bien modifié à travers les fonctions (dans le prototype des fonctions, c'est signé de la sorte : mlVec3 **_bP et donc pas par référence). C'est pour cela que je ne comprends pas pourquoi cela ne marchait pas.

(Ceci dit, votre code fonctionne très bien, merci beaucoup).

Salut,

De plus, tu pourrais te faciliter énormément la vie en considérant le fait que, si ton tableau doit avoir L lignes et C colonnes, il doit, tout simplement, contenir... L*C éléments...

En première approche, il y a trois avantages majeurs à cette manière de voir les choses:
1- Le code permettant de créer ton tableau 2D est beaucoup plus résistants aux exceptions (new lance classiquement une exception "std::bad_alloc" s'il échoue, et tu auras énormément de problème si t[dim_allouee] = new T[_dim2]; échoue alors dim_allouee vaut plus de 0 et moins de _dim1-1)

2- Tu évite une indirection "inutile": au lieu de te trimbaler avec des pointeurs de pointeurs, des références sur pointeurs de pointeurs ou, pire encore, avec des pointeurs de pointeurs de pointeurs ( T*** ), tu pourras te contenter de pointeurs, de références sur un pointeur ou, au pire, d'un pointeur de pointeur

3- Lorsqu'il s'agira de libérer correctement la mémoire allouée, un simple

Code:

---

delete [] leTableau;

---

sera suffisant, alors qu'autrement, tu devrais :

• boucler sur tous les élément de la première dimension pour les détruire un à un
• détruire la première dimension elle-même

Enfin, il n'est pas plus compliqué de gérer les indices sous cette forme, la formule étant tout simplement (toujours pour L lignes et C colonnes, en devant accéder à l'objet se trouvant à la ligne li et à la colonne co): li*C + co.

Au pire, tu pourrais éventuellement être confronté à un problème si le nombre de lignes et de colonnes demandées était à ce point important qu'il est impossible de trouver un espace mémoire suffisant disponible... Mais, avec les quantités de mémoire dont on dispose actuellement, le risque est... limité, dirons nous :D

Bonsoir Koala,

Je ne suis pas sur d'avoir compris où vous vouliez en venir : si j'ai bien compris, vous me conseillez d'utiliser des tableaux à une dimension (vous ne l'avez mentionné nul part, c'est pour cela ^^) plutôt qu'à deux dimensions pour les raisons précitées.

Je comprends et je suis d'accord, j'avais besoin d'accéder à plusieurs cases différentes en même temps pour faire des GL_QUAD, pour paver une surface de Bézier, c'est pour ça que j'ai préféré faire ça en 2D ^^

Citation:

---

D'accord, je pensais que comme je passais un pointeur en paramètre, je travaillais directement dessus.

---

Tu vas travailler directement sur ce qui est pointé, donc les données du tableau. Mais la variable _t en elle-même est une copie du pointeur que tu passes. Si on avait voulu utiliser un pointeur plutôt qu'une référence pour travailler sur cette variable, il aurait fallu passer un T*** (ie. un pointeur sur la variable à modifier, de type T**).

Comme ça ce sera peut-être plus évident :

Code:

---

1 2 3 4

typedef T** tableau;   void f1(tableau _t); // là je travaille sur une copie du pointeur (T**) void f2(tableau* _t); // là je travaille sur l'adresse du pointeur original (T***)

---

Citation:

---

Envoyé par Daikyo

Bonsoir Koala,

Je ne suis pas sur d'avoir compris où vous vouliez en venir : si j'ai bien compris, vous me conseillez d'utiliser des tableaux à une dimension (vous ne l'avez mentionné nul part, c'est pour cela ^^) plutôt qu'à deux dimensions pour les raisons précitées.

---

C'est bien cela, je confirme ;)

Citation:

---

Je comprends et je suis d'accord, j'avais besoin d'accéder à plusieurs cases différentes en même temps pour faire des GL_QUAD, pour paver une surface de Bézier, c'est pour ça que j'ai préféré faire ça en 2D ^^

---

Tu "sélectionnera" malgré tout les différents éléments un à un...

Si, pour une fonction donnée, tu dois manipuler trois éléments, tu passera sans doute 3*2 valeurs permettant de déterminer les coordonnées de ces trois éléments:

Code:

---

1 2 3 4 5 6 7

void foo(type ** tab, int dx, int dy, int cx, int cy, int fx, int fy) { type debut = tab[dy][dx]; type centre = tab[cy][cx]; type fin = tab[fy][fx]; /* travailler avec debut, centre et fin */ }

---

mais il n'est pas plus difficile de travailler avec un tableau à une dimension:

Code:

---

1 2 3 4 5 6 7

void bar(type * tab, int dx, int dy, int cx, int cy, int fx, int fy) { type debut = tab[dy*MAX_X+dx]; type centre = tab[cy*MAX_X+cx]; type fin = tab[fy*MAX_X+fx]; /* travailler avec debut, centre et fin */ }

---

Sinon, il y a toujours cette option.

@ Laurent Gomila
Ok donc si je passe un T** en paramètre d'une fonction, je ne pourrais pas modifier le pointeur mais je pourrais accéder et modifier le contenu des cases de mon tableau. Si je passe un T***, je pourrais modifier le pointeur. C'est ça ?

@ Koala & Médinoc
Très bien, merci beaucoup pour ces compléments !

PS: Je verrais pour passer ma fonction à un tableau 1D.

Citation:

---

Ok donc si je passe un T** en paramètre d'une fonction, je ne pourrais pas modifier le pointeur mais je pourrais accéder et modifier le contenu des cases de mon tableau. Si je passe un T***, je pourrais modifier le pointeur. C'est ça ?

---

Oui.