Discussion :

[nadia75]

Bonjour à tous,

comment fait-on pour passer à une fonction et parcourir mon tableau de pointeurs TAB de tableau à deux dimensions:
J'ai deux tableaux à deux dimensions: Tab1 et Tab2

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
 
int Tab1 [8][4] ={ {1,1,2,2},
                   {2,0,1,3},
                   {3,1,2,3},
                   {3,0,3,4},
                   {4,1,0,5},
                   {5,1,3,6},
		   {6,1,0,7} };
/**************************************/
int Tab2 [8][4] ={ {2,0,1,3},
                   {2,0,7,3},
                   {3,1,2,3},
                   {3,0,3,4},
                   {3,1,2,3},
                   {5,1,3,6},
                   {6,1,0,7} };
/**************************************/
 
int (*p1)[4]; // je crée un pointeur sur Tab1
p1=Tab1;      // affectation 
int(* p2)[4];
p2=Tab2;
 
int (*TAB[2])[4]; // je crée le tableau de pointeur
TAB[0]=p1;	// pointeur de Tab1 sur le premier élément de mon tableau 
 
TAB[1]=p2; // pointeur de Tab2 sur le premier élément de mon tableau

merci

[cynique]

void f( int (*la_tab[])[4] );
void g( int (**la_tab)[4] );

f ( TAB );
g( TAB );

[méphistopheles]

void f( int (*la_tab[])[4] );
void g( int (**la_tab)[4] );

f ( TAB );
g( TAB );

houlà, pas sûr que ça marche... et très sale.

On peut faire simplement comme cela:

Code :

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

1
2
3
void f( int** montableau, size_t taille1, size_t taille2)
{
}

par contre, il est sans doute plus pertinent d'utiliser une des structures de donnée fournie par la stl ou bien boost::array.

sinon,

****************************/

int (*p1)[4]; // je crée un pointeur sur Tab1
p1=Tab1; // affectation
int(* p2)[4];
p2=Tab2;

pourquoi ne pas écrire

Code :

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

1
2
3
4
	int **p1; // je crée un pointeur sur Tab1
	p1=Tab1;      // affectation 
	int**p2;
	p2=Tab2;

C'est aussi fonctionel et bien plus propre... par contre, attention, ça ne recopie pas le tableau, juste le pointeur !

bonne chance

[Lucien63]

Si le but est de mettre ces pointeurs dans un tableau, c'est peut-être encore plus simple de faire comme ceci :

Code :

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

1
2
3
int (*Tab[2])[4];
Tab[0]=Tab1;
Tab[1]=Tab2;

PS: Tes tableaux son composé de huit tableaux de quatre éléments mais initialisé avec sept tableau de quatre élément, je ne sais pas si c'est volontaire ?

[Lucien63]

Pour répondre à ta question comment passer ce tableau à une fonction :
C'est pas évident à expliquer alors rien de mieux qu'un exemple :
La fonction :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void ftab(int (**Tab)[4], int nElem, int nbTab)
{
  for(int z=0; z<nbTab; z++)
  {
    for(int x=0; x<nElem; x++)
      {
        for(int y=0; y<4; y++) std::cout << Tab[z][x][y] << " ";
        std::cout << std::endl;
      }
  }
}

L'utilisation :

Code :

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

1
2
3
4
5
int (*Tab[2])[4];
Tab[0]=Tab1;
Tab[1]=Tab2;
 
ftab(Tab, 8, 2);

[hiura]

Pour se simplifier la vie il existe les std::vector. C'est très bien de les utiliser quand on débute.

[Kaktus]

Pourquoi ne pas faire qu'un seul tableau puisque tu connais toutes les tailles ?
un float tab[16] peut très bien remplacer un float tab[4][4] (matrices notamment).

C'est toujours la misère les tableaux a deux dimensions je trouve .

[JulienDuSud]

Il faut aussi savoir qu'un tableau à deux dimensions est représenté en mémoire comme un tableau à une dimension. Il est également possible d'accéder aux éléments du tableau via un pointeur simple.

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
 
const int SIZE_Y = 8;
const int SIZE_X = 4;
int tab[SIZE_Y][SIZE_X];
 
int *ptr = &tab[0] + SIZE_Y*y + x; // ptr est un pointeur vers tab[y][x]
int *ptr2 = &tab[0] + SIZE_Y*y; // ptr2 est un pointeur vers tab[y][0]
++ptr2; // ptr2 pointe vers tab[y][1]
 
void f( int* t )
{
   *t = 2;
}
 
f( ptr );
 
std::cout << t[y][x] << std::endl; // affichera 2

C'est du C