Discussion :

[didierl]

Connaitriez vous une façon pour convertir un pointeur (ici wp) de type:

char* wp;
ou
char* wp[n];

en un pointeur de type:

char* wp[x][y][z]

où x, y, z sont des constantes ou des variables telles que n=x*y*z (ex. convertir char* wp[24] en char* wp[2][3][4]).

Merci.

Didier

[Médinoc]

On ne peut convertir en tableau multi-dimensionnel qu'avec des constantes (sauf peut-être avec les VLA en C99...)

(Je ne me souviens plus de la syntaxe sans typedef)

Code :

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

1
2
3
4
5
6
7
8
typedef char CHAR_3_4[3][4]; /* CHAR_3_4 correspond au type char[3][4] */
 
void func(char pwp[2][3][4]);
 
char *wp = NULL;
CHAR_3_4 * wp2 = (CHAR_3_4 *)wp;
 
func(wp2);

(Ceci compile sans problème en C++, et devrait compiler aussi en C)

[didierl]

On ne peut convertir en tableau multi-dimensionnel qu'avec des constantes (sauf peut-être avec les VLA en C99...)

(Je ne me souviens plus de la syntaxe sans typedef)

Code :

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

1
2
3
4
5
6
7
8
typedef char CHAR_3_4[3][4]; /* CHAR_3_4 correspond au type char[3][4] */
 
void func(char pwp[2][3][4]);
 
char *wp = NULL;
CHAR_3_4 * wp2 = (CHAR_3_4 *)wp;
 
func(wp2);

(Ceci compile sans problème en C++, et devrait compiler aussi en C)

Dommage que ce ne soit pas plus général et qu'on ne puisse faire la même chose avec des variables.
Merci pour la réponse.

[Emmanuel Delahaye]

Connaitriez vous une façon pour convertir un pointeur (ici wp) de type:

char* wp;
ou
char* wp[n];

en un pointeur de type:

char* wp[x][y][z]

où x, y, z sont des constantes ou des variables telles que n=x*y*z (ex. convertir char* wp[24] en char* wp[2][3][4]).

Je ne pense pas que ce soit possible, surtout dynamiquement.

Si tu veux adresser un bloc linéaire en 3D, il faut écrire une fonction qui calcule l'adresse de l'élément en fonction de 'adresse de dépaer et des 3 coordonnées. On utilise pour ça une formule qui tient compte des n-1 dimensions en partant de la droite.

[didierl]

Je ne pense pas que ce soit possible, surtout dynamiquement.

Si tu veux adresser un bloc linéaire en 3D, il faut écrire une fonction qui calcule l'adresse de l'élément en fonction de 'adresse de dépaer et des 3 coordonnées. On utilise pour ça une formule qui tient compte des n-1 dimensions en partant de la droite.

J'avais bien pensé à cette solution mais qui est un peu lourde.
En tout cas merci.

[Jean-Marc.Bourguet]

Connaitriez vous une façon pour convertir un pointeur (ici
wp) de type:

char* wp;

Ok

char* wp[n];

Ceci n'est pas un pointeur mais un tableau de n pointeurs vers char

en un pointeur de type:

char* wp[x][y][z]

et ceci un tableau tridimentionnel de pointeurs vers char

où x, y, z sont des constantes ou des variables telles que n =x*y*z (ex. convertir char* wp[24] en char* wp[2][3][4]).

Comme ce que tu me demandes n'a guère de sens, je vais répondre à une autre question. Premièrement, si y ou z sont des variables, il n'y a rien à faire. Si ce sont des constantes, que x est une constante aussi et que tu as un

Code :

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

char* wp;

pointant vers un tableau de x*y*z char, tu peux le convertir sans risque en un

Code :

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

char (*pt_tab)[x][y][z] = (char (*)[x][y][z])wp;

que tu peux utiliser comme ceci:

Code :

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

(*pt_tab)[i][j][k]

Plus confortable, et permettant que x soit variable (mais pas y ou z), tu peux aussi faire:

Code :

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

char (*pt_tab)[y][z] = (char (*)[y][z])wp

que tu peux utiliser comme ceci:

Code :

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

pt_tab[i][j][k]

Si tu fais ce genre de chose, je te conseille d'utiliser des typedefs plutôt que des notations comme

Code :

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

char (*)[x][y][z]

[didierl]

Ok



Ceci n'est pas un pointeur mais un tableau de n pointeurs vers char



et ceci un tableau tridimentionnel de pointeurs vers char



Comme ce que tu me demandes n'a guère de sens, je vais répondre à une autre question. Premièrement, si y ou z sont des variables, il n'y a rien à faire. Si ce sont des constantes, que x est une constante aussi et que tu as un

Code :

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

char* wp;

pointant vers un tableau de x*y*z char, tu peux le convertir sans risque en un

Code :

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

char (*pt_tab)[x][y][z] = (char (*)[x][y][z])wp;

que tu peux utiliser comme ceci:

Code :

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

(*pt_tab)[i][j][k]

Plus confortable, et permettant que x soit variable (mais pas y ou z), tu peux aussi faire:

Code :

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

char (*pt_tab)[y][z] = (char (*)[y][z])wp

que tu peux utiliser comme ceci:

Code :

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

pt_tab[i][j][k]

Si tu fais ce genre de chose, je te conseille d'utiliser des typedefs plutôt que des notations comme

Code :

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

char (*)[x][y][z]

Ma question n'a guère de sens, mais c'est marrant on dirait que tu as quand même compris...

[koala01]

Salut,

Ma question n'a guère de sens, mais c'est marrant on dirait que tu as quand même compris...

A vrai dire, elle n'a pas énormément de sens du simple fait que, quand tu déclare un tableau (uni ou multi dimentionnel), tu déclare aussi... un pointeur sur le premier élément, qui sert de pointeur sur le tableau lui meme...

Hormis que l'un serait une allocation statique et que l'autre serait une allocation dynamique, le deux codes suivants seraient sensiblement pareils (disposer de 2*3*4=24 caractères, et en prenant quand meme un sérieux raccourcis):

Code :

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

1
2
3
4
5
 
char MaVar[2][3][4];
char *ptr;
ptr=malloc(sizeof (char*2*3*4));
//en n'oubliant pas de vérifier la réussite de l'allocation ;-)

Il est à noter que la représentation en mémoire sera exactement pareille, identique meme à un simple char MaVar[24], la seule différence apparaissant au niveau du nombre de cases mémoires qui sont passées lors de l'incrémentation de chaque dimention

Si tu déclare un tableau (uni ou multi dimentionnel) de pointeurs sous la forme de

Code :

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

1
2
 
char* wp[x][y][z];

il s'agira alors de veiller à ce qu'une adresse mémoire soit fournie pour chacun des 24 pointeurs dont du disposera...soit par allocation dynamique, soit par affectation d'une adresse à laquelle se trouve déjà un (tableau de) caractère(s)

Pour un tableau à deux ou trois dimentions ne contenant "que" 24 éléments (qu'il s'agisse de caractères ou de pointeurs ), il est peut etre tout aussi facile de décider de travailler sur un tableau à une seule dimention et de faire le calcul soi meme:

Avec x, y et z représentant les positions recherchées respectives

Code :

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

1
2
3
 
char caractrer[24];
caractere[12*z+4*y+x];

donnerait exactement le meme résultat que

Code :

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

1
2
3
 
char caractere[2][3][4];
caractere[z][y][x];

[didierl]

Salut,

A vrai dire, elle n'a pas énormément de sens du simple fait que, quand tu déclare un tableau (uni ou multi dimentionnel), tu déclare aussi... un pointeur sur le premier élément, qui sert de pointeur sur le tableau lui meme...

Hormis que l'un serait une allocation statique et que l'autre serait une allocation dynamique, le deux codes suivants seraient sensiblement pareils (disposer de 2*3*4=24 caractères, et en prenant quand meme un sérieux raccourcis):

Code :

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

1
2
3
4
5
 
char MaVar[2][3][4];
char *ptr;
ptr=malloc(sizeof (char*2*3*4));
//en n'oubliant pas de vérifier la réussite de l'allocation ;-)

Il est à noter que la représentation en mémoire sera exactement pareille, identique meme à un simple char MaVar[24], la seule différence apparaissant au niveau du nombre de cases mémoires qui sont passées lors de l'incrémentation de chaque dimention

Si tu déclare un tableau (uni ou multi dimentionnel) de pointeurs sous la forme de

Code :

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

1
2
 
char* wp[x][y][z];

il s'agira alors de veiller à ce qu'une adresse mémoire soit fournie pour chacun des 24 pointeurs dont du disposera...soit par allocation dynamique, soit par affectation d'une adresse à laquelle se trouve déjà un (tableau de) caractère(s)

Pour un tableau à deux ou trois dimentions ne contenant "que" 24 éléments (qu'il s'agisse de caractères ou de pointeurs ), il est peut etre tout aussi facile de décider de travailler sur un tableau à une seule dimention et de faire le calcul soi meme:

Avec x, y et z représentant les positions recherchées respectives

Code :

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

1
2
3
 
char caractrer[24];
caractere[12*z+4*y+x];

donnerait exactement le meme résultat que

Code :

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

1
2
3
 
char caractere[2][3][4];
caractere[z][y][x];

Sauf à l'utiliser...