Conversion de type de pointeur

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

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:

---

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)

Citation:

---

Envoyé par 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]).

---

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.

Citation:

---

Envoyé par 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:

---

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.

Citation:

---

Envoyé par Emmanuel Delahaye

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.

Citation:

---

Envoyé par didierl

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

char* wp;

---

Ok

Citation:

---

char* wp[n];

---

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

Citation:

---

en un pointeur de type:

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

---

et ceci un tableau tridimentionnel de pointeurs vers char

Citation:

---

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:

---

char* wp;

---

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

Code:

---

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

---

que tu peux utiliser comme ceci:

Code:

---

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

---

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

Code:

---

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

---

que tu peux utiliser comme ceci:

Code:

---

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:

---

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

---

Citation:

---

Envoyé par Jean-Marc.Bourguet

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:

---

char* wp;

---

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

Code:

---

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

---

que tu peux utiliser comme ceci:

Code:

---

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

---

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

Code:

---

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

---

que tu peux utiliser comme ceci:

Code:

---

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:

---

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

Salut,

Citation:

---

Envoyé par didierl

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:

---

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:

---

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:

---

1 2 3

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

---

donnerait exactement le meme résultat que

Code:

---

1 2 3

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

---

Citation:

---

Envoyé par koala01

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:

---

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:

---

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:

---

1 2 3

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

---

donnerait exactement le meme résultat que

Code:

---

1 2 3

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

---

---

Sauf à l'utiliser...