Passage de paramètres par pointeur, en cascade

Faire correspondre le code au plus proche de ce qui se passe en ASM

Citation:

---

Envoyé par souviron34

Citation:

---

Si il s'agit de faire pointer ptr sur le dernier double alloué, ceci est faux

---

per che ? ...

---

à cause du sizeof(double)

Code:

---

ptr = ptr + (taille-1)*sizeof(double);

---

Citation:

---

Envoyé par babykichon

Faire correspondre le code au plus proche de ce qui se passe en ASM

---

En général, on essaye plutôt de se fiche pas mal de l'assembleiur, et de faire correspondre le code au plus près de la formulation humaine.... et dans ce cas mathématique...

Comme ça, que tu aies 1, 2, ou N processeurs, que tu soit sur un x86, un RISC ou un CISC, ou n'importe quoi, le code ne change pas.. Et c'est bien ce que propose C...

Citation:

---

Envoyé par diogene

à cause du sizeof(double)

Code:

---

ptr = ptr + (taille-1)*sizeof(double);

---

---

Explicite, je ne comprend toujours pas..

L'arithmétique des pointeurs tient compte implicitement de la taille des objets pointés.

ptr est un double *. ptr = ptr + (taille-1) ptr pointe alors sur le (taille-1)ieme double apres celui pointé à l'origine par ptr.

ptr = ptr + (taille-1)*sizeof(double) n'a pas de sens. On ne trouve (pratiquement) jamais de sizeof dans des expressions de calcul d'adresses (sauf à la rigueur des sizeof x/ sizeof *x où x est un tableau)

Citation:

---

Explicite, je ne comprend toujours pas..

---

tu pointeur étant déjà typé à double* il avancera forcément de sizeof(double), l'écriture correcte est donc :

Code:

---

ptr = ptr + (taille-1);

---

Suffit de faire un test.

Code:

---

1 2 3 4 5 6 7 8

double *ptr; ptr = malloc(constante*sizeof(double));   printf("adresse ptr = %d\n", ptr);   ptr++;   printf("adresse ptr = %d\n", ptr);

---

---> L’incrémentation s'est faite de 8.

______________________


Sinon pour le lien entre le C et l'ASM, je ne veux pas faire complètement correspondre le code. Mais Concernant les buffer circulaire j'aimerais qu'ils tournent de la même façon en C qu'en ASM.

C'est a dire :

en C je peux juste me faire un petit buffer modulo du type :

Code:

---

1 2 3 4 5 6 7 8

double value[constante]; int x; . . //process while ou boucle value[x++]= .... x % = constante;

---

Le problème est que ce comportement est inexistant sur DSP, sur lequel tu configures un buffer avec une adresse de début et de fin, et il fait simplement un compare pour revenir en début lorsque tu es en fin.

Le code C que j’écris sera peut être intégré directement sur la target, peut être une partie seulement sera en ASM, je ne sais pas encore. Dans le doute, j'essaye de rendre ce buffer le plus transparent possible, comme ça dans mon code je ne fais qu'utiliser un pointeur que j’incrémente ou décrémente, comme en ASM. L’étape du modulo je la code dans un fichier "tampon" pour l'exclure du code générique.
EDIT : Lorsque je dis, l’étape modulo, j'entends le compare entre adresse courante/fin, qui est complètement transparent sur la target.

Du coup lorsque je le réécris en ASM, suffit de recopier bêtement mon code C générique, qui sera déjà optimisé sur ce point la.

Enfin je suis pas très doué pour les explications ... j’espère que je suis assez clair lol

Citation:

---

Envoyé par diogene

L'arithmétique des pointeurs tient compte implicitement de la taille des objets pointés.

ptr est un double *. ptr = ptr + (taille-1) ptr pointe alors sur le (taille-1)ieme double apres celui pointé à l'origine par ptr.

ptr = ptr + (taille-1)*sizeof(double) n'a pas de sens. On ne trouve (pratiquement) jamais de sizeof dans des expressions de calcul d'adresses (sauf à la rigueur des sizeof x/ sizeof *x où x est un tableau)

---

vi vii t'as raison :oops::oops: je reviens de vacances et j'avais la tête dans ... ailleurs dirons-nous...

de toutes façons j'aurais normalement écris plutôt :

Code:

---

ptr = &(x[taille-1]);

---

si j'avais voulu faire ça..

Citation:

---

Envoyé par babykichon

oui c'est exactement l'idee, sauf que la ligne du for de la fonction je la rend generique en la remplacant par une fonction qui fera appel a un autre fichier qui pourra etre changer.

Et que je ne veux voir aucune [i] dans le code :D

Mais sinon c'est ca ^^

---

Ce qui ne change strictement rien par rapport à ce que j'ai écris :

Code:

---

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 28 29 30 31 32 33

int main (void) { double *ptr, *x, Result; ptr = malloc ( taille* sizeof(double)); x = malloc ( taille*sizeof(double)); . . Result = function1(ptr, x, .....); . }   double function1(double *ptr, double *x .....) { double Res ; int i ;   x = x + (taille-1) ;   for (i=(taille-1);i>= 0;i--) { Res = Res + function2(*ptr, *x); ptr++ ; x-- ; }   return Res ; }   double function2 ( double ptrVal, double xVal) { double Res = ptrVal + xVal ;   return Res ; }

---

tes variables ptr et x étant locales à la fonction function1, les décrémenter ou incrémenter ne modifie pas leurs valeurs à l'extérieur, et donc quand on ressort de function1 les valeurs sont inchangées, rendant caduque l'histore de redémarrer cycliquement.. C'est cycliquement programmé...

Dans mon code, X est local a fonction1 ok, mais pas ptr qui vient du main et doit etre modifie par function1 et 2.

j'ai pas poste le code complet car ca sortait du cadre du sujet.

Enfin, tout marche comme je le souhaites merci pour votre aide :ccool:

Citation:

---

mais pas ptr qui vient du main et doit etre modifie par function1 et 2

---

ptr est bien une variable locale à la fonction function1() initialisée avec la valeur du ptr de main().
Le ptr du main ne sera pas modifié par function1()

A mon premier post, non tu as raison, mais j'ai modifie le code depuis.

Je te remercie :ccool:

oui mais ce qu'on te dit c'est que si tu veux faire "cyclique", il ne fallait pas faire cette modif, car ça le fait tout seul.. :P:P

Bon finalement j'ai vire toutes les locales, comme me l'avait dit tres justement j'écrasais la valeur passe en parametre du main a la fonction1.

En faite pour coller vraiment su titre, pour envoyer la meme reference en cascade je suis arrive a un truc du genre :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

int main() { double *ptr; ptr= malloc(NbCoefFIR *sizeof(double)); . . . . ptr++; //incremente l'adresse function1(&ptr,....); //prototype -> function1(double **ptr,...) }

---

Code:

---

1 2 3 4 5 6 7 8 9

int function1(double **ptr,...) { . (*ptr)++; //incremente l'adresse . function2(&*ptr,...); //prototype -> function2(double **ptr,...) . }

---

Code:

---

1 2 3 4 5 6 7 8 9 10

function2(double **ptr,....) { . . **ptr = X; //modifie la valeur du buffer a l'adresse *ptr (*ptr)++; //incremente l'adresse . . }

---

Alors bon, ca marche ... mais j'ai comme le sentiment d'etre parti en vrille ...
:aie:

Un détail :

Code:

---

function2(&*ptr,...); //prototype -> function2(double **ptr,...)

---

&*ptr c'est simplement ptr :

Code:

---

function2(ptr,...); //prototype -> function2(double **ptr,...)

---

Ah oui ... aussi ....


....

:aie:

Merci chef !