Discussion :

[Daikyo]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Laurent Gomila]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Daikyo]

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

[koala01]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

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

[Laurent Gomila]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[koala01]

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

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 */
}

[Médinoc]

Sinon, il y a toujours cette option.

[Daikyo]

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

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

Oui.