Recuperation d'une adresse dans un tableau de *void

Je cherche par tous les moyens mais je n'y arrive pas alors je post.
j'ai un tableau de void*

Code:

---

1 2 3 4

int stars1[NB_STARS][2]={0}, stars2[NB_STARS][2]={0}, stars3[NB_STARS][2]={0}; SDL_Surface *ecran=NULL;   void *adresses[4]={&stars1, &stars2, &stars3, &ecran};

---

*adresse est utilisé pour une fonction de callback(timer) :

Code:

---

timer=SDL_AddTimer(17, anim, adresses);

---

et voici le debut d'"anim" :

Code:

---

1 2 3 4

Uint32 anim(Uint32 intervalle, void *pointeur) { SDL_Surface *screen=(SDL_Surface*)(pointeur+3); [...] }

---

Seulement en vérifiant les adresses de screen et ecran sont différentes j'ai l'impression qu'il me prend l'adresse pointée par pointeur et qu'il y ajoute 3. mais je vois pas comment faire autrement(j'ai essayé pas mal de truc avec a chaque coup une erreur de compilation).
Merci de votre aide.

&écran correspond au 4 ème élément de ton tableau de pointeur void.

La position de (void *)&écran est donc :

Code:

---

1 2	(pointeur + 3) ou &pointeur[3]

---

Le contenu de cette zone est :

Code:

---

1 2	&ecran = *(pointeur + 3) ou pointeur[3]

---

C'est donc un SDL_Surface **

Pour avoir la valeur de ton SDL_Surface * ecran, il faut mettre :

Code:

---

1 2	*(SDL_Surface **)pointeur[3];

---

(je ne suis pas sûr qu'on ai le droit de mettre directement un * avec un pointeur void)

Citation:

---

Envoyé par stc074

[CODE]Uint32 anim(Uint32 intervalle, void *pointeur) {
SDL_Surface *screen=(SDL_Surface*)(pointeur+3);
[...]

---

J'ai un gros doute là.

Il me semble que par défaut l'arithmétique sur un pointeur void fera que tu avance de 1 en 1.

Donc pour moi, (pointeur + 3), sera une adresse 3 octets plus loin que 'adresses'.

Ce serait moins tordu (prise de tête ?) si tu utilisais une structure :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

struct timer_data_s { int * stars1; int * stars2; int * stars3; SDL_Surface * ecran; }; /* ... */ struct timer_data_s timer_data = {&stars1, &stars2, &stars3, ecran}; /* ... */ SDL_AddTimer(17, anim, &timer_data); /* ... */ Uint32 anim(Uint32 intervalle, void *pointeur) { struct timer_data_s *timer_data = (struct timer_data_s *)pointeur; SDL_Surface *screen = timer_data->ecran; /* ... */ }

---

Citation:

---

Donc pour moi, (pointeur + 3), sera une adresse 3 octets plus loin que 'adresses'.

---

Je crois plutôt que l'arithmétique des pointeurs sur void est à proscrire et provoquent un comportement indéfini.

salut je ne comprends pas trop l'intérêt d'utiliser un tableau de void*...
void * c'est pour utiliser principalement des pointeurs de fonctions ou alors pour passer un type générique à une fonction quitte à réarranger l'alignement en mémoire avec un cast ( transtypage)

Comme l'écrit Diogene c'est pas coneillé à utiliser
A quoi sert la structure stars ?
Tu devrais mieux gérer des listes chainées pour ça

Il ne fait pas d'arithmétique sur des pointeurs void mais sur des pointeurs de pointeurs void.

Code:

---

1 2 3

void *tab; //pointeur void void *tab[5]; //pointeur de pointeur void pointant sur tab[0]

---

Non Neckara. Quand il fait ça

Code:

---

1 2 3 4

Uint32 anim(Uint32 intervalle, void *pointeur) { SDL_Surface *screen=(SDL_Surface*)(pointeur+3); [...] }

---

'pointeur' est bien un pointeur "tout court"...

J'ai compris d'où vient son erreur :

Code:

---

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

int stars1[NB_STARS][2]={0}, stars2[NB_STARS][2]={0}, stars3[NB_STARS][2]={0}; SDL_Surface *ecran=NULL; void *adresses[4]={&stars1, &stars2, &stars3, &ecran}; // void *adresses[4]={&stars1, &stars2, &stars3, ecran}; serait mieux mais il faudra modifier la suite timer=SDL_AddTimer(17, anim, (void *)adresses); Uint32 anim(Uint32 intervalle, void *pointeur) void *adresse[4] = (void **)pointeur; SDL_Surface *screen=*(SDL_Surface **)adresse[3]; [...] }

---

Voila...

Mais je ne l'encouragerais pas à continuer dans cette voie.

J'ai joué à cela aussi en SDL. Le plus simple que j'ai trouvé est ceci:

1) Faire un typedef pour une structure, par exemple

Code:

---

1 2 3 4 5 6

typedef struct GETT_cursInfo { int state; int insert; SDL_Rect *cursCoord; SDL_Surface *cursOn,*cursOff,*wnd; } s_cursInfo;

---

2) Dans la fonction voulue, déclarer un variable de ce type et la munir des données nécessaires à la fonction de callback (exemple):

Code:

---

1 2 3 4 5 6

s_cursInfo cursInfo; ... cursInfo.state=1; cursInfo.insert=1; cursInfo.cursCoord=&coordoneesCurseur; ...

---

3) Dans la fonction voulue, mettre le timer de SDL en route:

Code:

---

cursTimer=SDL_AddTimer(GETT_BLINK_DELAY,GETT_BlinkCursor,&cursInfo);

---

4) Et déclarer la fonction de callback:

Code:

---

1 2 3 4 5 6 7 8 9 10

Uint32 GETT_BlinkCursor(Uint32 delay,void *info) { s_cursInfo *p;   p=info; SDL_BlitSurface((p->state==GETT_CURS_EMPTY||p->insert==0)?(p->cursOn):(p->cursOff),NULL,p->wnd,p->cursCoord); SDL_UpdateRect(p->wnd,p->cursCoord->x,p->cursCoord->y,1,p->cursOn->h); p->state=(p->state==GETT_CURS_EMPTY)?GETT_CURS_FULL:GETT_CURS_EMPTY; return(delay); }

---

Pas besoin de jouer avec des pointeurs void!
L'avantage (à mon sens) d'utiliser une structure, c'est que l'on peut se permettre d'y oter ou d'y rajouter des éléments; la stucture du programme restera inchangée.

Edgar.

Merci pour vos réponse, je ne savais pas qu'il était déconseillé d'utiliser des tableau de *void, je débute vraiment (C'est le forum débutant non ?)
La solution de la structure me parait la meilleure, mais malgré ça je vais faire autrement en réutilisant directement mes tableaux (ils sont déclarés en haut du fichier donc ils englobent la fonction de callback).
J'essayais de comprendre un peu mieux les pointeurs c'est pas évident quand on débute, ça viendra a force je pense.
Merci.