Discussion :

[babykichon]

Salut,

comme le titre l'indique, j'ai un petit soucis de passage de paramètres par pointeur ... Il y a surement un truc que je n'ai pas bien assimilé ...

Voici ma facon de proceder :

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
28
29
30
31
32
main ()
{
double *ptr;
ptr = malloc ( taille* sizeof(double));
.
.
function1(ptr, .....);
.
}

function1(double *ptr, .....)
{
ptr = var_constante//provenant d'une var globale
.
.
for (i=(taille-1);i>= 0;i--)
function2(ptr,....);
.
.
}

function2(double *ptr, .....)
{
resultat = resultat + (*ptr * local_x); //resultat et local_x sont déclares
                          //localement et pointe sur des tableaux 

ptr--;
.
if (ptr_Hn == adr_start_Hn)   //adr_start_Hn
ptr_Hn = adr_end_Hn;          //adr_end_Hn -> 2 variables globales
.
}

Donc voici mon probleme :
dans la function2 :
ptr correspond bien a l'adresse et *ptr a la valeur pointee par celle-ci

Cependant la nouvelle valeur de l'adresse de ptr apres la decrementation n'est pas retenue par la function1 et elle renvoie toujours la meme, voici l'affichage d'un petit debug histoire de vous eclairer :

function1 :
adresse de ptr = 100

function2 :
adresse de ptr = 100 avant le "ptr--"
adresse de ptr = 92 apres le "ptr--"

retour function1 (dans la boucle for)
adresse de ptr = 100 .....


Alors bon je peux mettre le "ptr--" dans la function1 juste apres l'appel de la function2 et tout marche tres bien comme ca ...
Mais j'ai vraiment besoin de mettre ce process dans la function2.

J'ai du me perdre quelquepart, et j'espere ne pas vous avoir perdu lors de l'explication du probleme.

Si quelqu'un a une idee, merci beaucoup

[TheGzD]

Ta fonction 2 tente de modifier un pointeur de ta fonction 1, il te faut donc passer l'adresse de ce pointeur à ton fonction 2 : ton erreur n'est pas une méconnaissance des pointeurs mais plutôt du fait qu'un passage en paramètre revient à faire une copie local à la fonction utilisant ce paramètre.

Ainsi en sortant de ta fonction ta copie (sur lequel tu as travaillée) est supprimée. L'intérêt d'un pointeur dans tout ça c'est que tu vas pouvoir modifier son contenu pointé qui lui n'est pas copié (seul le pointeur l'est !).

La signature de ta fonction 2 doit donc être la suivante :

Code :

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

function2(double **ptr, .....)

Et son appel (avec tes notations) :

Code :

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

function2(&ptr,....);

[babykichon]

je te remercie de ta reponse mais je ne suis pas sur de bien comprendre a quoi correspond le ptr une fois arrive dans la fonction2.

Pour moi :

En modifiant mon code en fonction de ta reponse, dans la function2 j'ai :

**ptr qui va correspondre a la valeur pointee par ptr de la fonction main.
*ptr son adresse.

Mais on dirait bien que non, car mon *ptr-- ne decremente pas l'adresse ... et j'arrive a des valeurs vraiment bizarre, je me suis vraiment perdu en route je crois la ...

les pointeurs ....

[babykichon]

Je ne suis peut être pas assez clair en faite :

J'ai compris le principe et l’utilité du passage de paramètre par pointeur, durant tout le process dans les différentes fonctions je ne veux modifier que le pointeur *ptr de la fonction main.

Dans la fonction main, le pointeur est initialise en début de l'espace mémoire alloue par le malloc.
Puis j’écris la valeur de debut et de fin de ce buffer dans deux var globales.

Toujours dans la fonction main, je rempli le buffer a la lecture d'un fichier avec un :

Code :

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

1
2
*ptr = valeur lue;  
ptr++; //incrémente l'adresse du pointeur

Puis j'envoie la référence du pointeur a la function1 avec :

Code :

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

function1(ptr, ...) //signature de la function1 : function1(double *ptr,..)

Dedans je modifie l'adresse du pointeur afin de me trouver en fin de buffer

Code :

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

ptr = adresse_de_fin;

puis j'envoie encore la référence a la function2 en suivant ta réponse :

Code :

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

function2( &ptr, ...) //signature function2(double **ptr)

dans cette fonction je viens lire les valeurs du buffer en commençant par la fin donc et je fais une opération avec ça :

Code :

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

result += **ptr *X;

et je décrémente l'adresse

Code :

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

*ptr--;

et je boucle.


Durant tout le process je ne veux donc jouer que sur le pointeur déclarer dans la main, en faite ca marchait en mettant le ptr-- dans la function1 mais je pense que ça ne faisait pas du tout ce que je pensais ....

Et en faisant comme je viens d’écrire, le décrément de l'adresse du pointeur ne se fait pas correctement.

En espérant être clair ....

[Golgotha]

Bonjour,

Tu ne peux pas "décrémenter une adresse".

pour que tu voie bien :

Je créer un objet int, je l’appel A.

donc, A à une adresse en mémoire (physique), et une valeur.
Disons que l'adresse de A est 100, et que ça valeur est 0.

donc, &A = 100 et A = 0.

Si tu fait un pointeur sur A, donc, un pointeur comme son nom l'indique pointe sur la case mémoire de la variable, ce n'est pas la variable. Notre pointeur s’appelle PA.

ça valeur est de 100 (adresse de A), et sont adresse est de 300 (case mémoire physique)

on sais que (*PA) permet de modifier directement le contenu de la case mémoire pointé, donc A.

Mais, si je décrémente PA, que ce passe t'il ?

PA passe par exemple à 97.

concrètement : l'adresse physique de PA ne change pas, elle est de 300, et l'adresse de A ne change pas non plus ! elle reste évidement à 100, il est à noté que notre pointeur, pointe maintenant sur une autre case mémoire que A, mais nus n'avons pas du tout modifier l'adresse physique de la variable A, et heureusement !

Petite dessin :

Avant la décrémentation, PA pointe sur la case 100, qui est notre variable A

-----------> 097 - [??]
-----------> 098 - [??]
-----------> 099 - [??]
[PA]-------> 100 - [A]
-----------> 101 - [??]
-----------> 102 - [??]
-----------> 103 - [??]

Les cases à coté sont d'autre variable, on ne les connais pas.

Après notre décrémentation :

[PA]-------> 097 - [??]
-----------> 098 - [??]
-----------> 099 - [??]
-----------> 100 - [A]
-----------> 101 - [??]
-----------> 102 - [??]
-----------> 103 - [??]

PA pointe une autre case mémoire, mais la variable A à toujours la même adresse.

[TheGzD]

tu peux me montrer tout ton code stp ?

[TheGzD]

C'est à mon avis exactement ce qu'il veut faire vu qu'il a allouer un tableau de double ... ou alors j'ai raté une étape

Bonjour,

Tu ne peux pas "décrémenter une adresse".

pour que tu voie bien :

Je créer un objet int, je l’appel A.

donc, A à une adresse en mémoire (physique), et une valeur.
Disons que l'adresse de A est 100, et que ça valeur est 0.

donc, &A = 100 et A = 0.

Si tu fait un pointeur sur A, donc, un pointeur comme son nom l'indique pointe sur la case mémoire de la variable, ce n'est pas la variable. Notre pointeur s’appelle PA.

ça valeur est de 100 (adresse de A), et sont adresse est de 300 (case mémoire physique)

on sais que (*PA) permet de modifier directement le contenu de la case mémoire pointé, donc A.

Mais, si je décrémente PA, que ce passe t'il ?

PA passe par exemple à 97.

concrètement : l'adresse physique de PA ne change pas, elle est de 300, et l'adresse de A ne change pas non plus ! elle reste évidement à 100, il est à noté que notre pointeur, pointe maintenant sur une autre case mémoire que A, mais nus n'avons pas du tout modifier l'adresse physique de la variable A, et heureusement !

Petite dessin :

Avant la décrémentation, PA pointe sur la case 100, qui est notre variable A

-----------> 097 - [??]
-----------> 098 - [??]
-----------> 099 - [??]
[PA]-------> 100 - [A]
-----------> 101 - [??]
-----------> 102 - [??]
-----------> 103 - [??]

Les cases à coté sont d'autre variable, on ne les connais pas.

Après notre décrémentation :

[PA]-------> 097 - [??]
-----------> 098 - [??]
-----------> 099 - [??]
-----------> 100 - [A]
-----------> 101 - [??]
-----------> 102 - [??]
-----------> 103 - [??]

PA pointe une autre case mémoire, mais la variable A à toujours la même adresse.

[babykichon]

Je te remercie de cette explication ca m'a permis et bien assimiler ce que je pensais.

Mais c'est exactement ce que je veux faire, j'ai un espace memoire alloue par un malloc et je veux pouvoir le parcourir.

[souviron34]

Ce qu'on t'a donné en première réponse est correct, mais je crois que tu as une incohérence dans ton raisonnement :

function1 :
adresse de ptr = 100

function2 :
adresse de ptr = 100 avant le "ptr--"
adresse de ptr = 92 apres le "ptr--"

retour function1 (dans la boucle for)
adresse de ptr = 100 .....


Alors bon je peux mettre le "ptr--" dans la function1 juste apres l'appel de la function2 et tout marche tres bien comme ca ...
Mais j'ai vraiment besoin de mettre ce process dans la function2.

Si tu veux mettre ton incrémentation dans la fonction 2, ça marche bien, MAIS c'est LOCAL ....

Je ne vois donc pas pourquoi tu voudrais que ton ptr dans la fonction 1 aie été modifié...

Sinon c'est la solution qu'on t'a donné plus haut...


D'autre part c'est pas bien de mettre un nom de variable passé en paramètre identique à un nom de variable locale :

Code :

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

1
2
3
4
5
6
7
8
9
10
function1(double *ptr, .....)
{
ptr = var_constante//provenant d'une var globale
.
.
for (i=(taille-1);i>= 0;i--)
function2(ptr,....);
.
.
}

[babykichon]

haha, oui mais c'est parce que dans ma tete c'etait pas une locale mais le pointeur sur la variable de la fonction d'avant ...

Le pointeur c'est *ptr ok, mais je veux modifier l'adresse pointe pas la valeur donc je suis descendu d'un cran ... Enfin je vais lire un cours sur les pointeurs je crois lol


Je veux bien modifier le decrement dans la function2 et que ca modifie la valeur de ce pointeur dans la function1 mais avec la solution qu'on ma donne plus haut ca marche pas encore ... doit y avoir d'autres incoherences

Les pointeurs c'est la vie

[souviron34]

Je veux bien modifier le decrement dans la function2 et que ca modifie la valeur de ce pointeur dans la function1 mais avec la solution qu'on ma donne plus haut ca marche pas encore ... doit y avoir d'autres incoherences

J'avoue ne pas comprendre pourquoi tu passes le ponteur en argument de fonction1 et que tu ne t'en sers pas mais l'écrase par le contenu de ta variable globale...

Un truc comme ça marche parfaitement :

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
28
29
30
31
32
33
main ()
{
double *ptr;
ptr = malloc ( taille* sizeof(double));
.
.
ptr = ptr + (taille-1)*sizeof(double);
function1(ptr, .....);
.
}
 
function1(double *ptr, .....)
{
ptr1 = ptr ;
.
.
for (i=(taille-1);i>= 0;i--)
function2(&ptr1,....);
.
.
}
 
function2(double **ptr, .....)
{
resultat = resultat + (*(*ptr) * local_x); //resultat et local_x sont déclares
                          //localement et pointe sur des tableaux 
 
*ptr = *ptr - 1 ;
.
if (ptr_Hn == adr_start_Hn)   //adr_start_Hn
ptr_Hn = adr_end_Hn;          //adr_end_Hn -> 2 variables globales
.
}

[babykichon]

Bon ben finalement ça marche, merci beaucoup pour vos réponses, et merci de ton aide TheGzD.

il fallait remplacer

Code :

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

*ptr--;

par

Code :

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

(*ptr)--;

Sinon merci pour la remarque du ptr du main dans la function1 ...
Complètement inutile ... je vais virer ca

Merchiiiiiiiiiiiiii

[diogene]

@souviron34

Code :

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

1
2
3
4
5
double *ptr;
ptr = malloc ( taille* sizeof(double));
.
.
ptr = ptr + (taille-1)*sizeof(double);

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

[souviron34]

@souviron34

Code :

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

1
2
3
4
5
double *ptr;
ptr = malloc ( taille* sizeof(double));
.
.
ptr = ptr + (taille-1)*sizeof(double);

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

per che ?

De toutes façons c'est une idée assez absurde de vouloir commencer par le dernier de cette manière, mais vu le décrément dans la fonction impliquée, je pense que c'est ce que voulais faire le PO...

[babykichon]

Si le code est faux j'en sais rien c'est pas moi qui ai ecrit ca, en revanche je suis interesse quand vous dites que c'est absurde de commencer par le dernier de cette facon.


Ma maniere de faire est la suivante :

Code :

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

1
2
3
4
5
6
7
 
 
double *ptr;
 
ptr = malloc(const*sizeof(double));
adr_start = ptr;                     
adr_end = ptr+ const-1;

Avec
adr_start et adr_end declare globale car je m'en sert un peu partout.

Lorsque je veux pointer a la fin, juste un petit
ptr = adr_end;

Est-ce absurde ?

[TheGzD]

Est-ce absurde ?

tout dépend de ce que tu cherches exactement à faire, après dans l'absolu je ne vois pas pourquoi ça serait absurde, mais il se peut que dans ton cas ça le soit


En tout cas n'oublie que "n'est absurde que l'absurdité" ...

[babykichon]

C'est pour coder un fir
donc

somme de x[n-k]*h[k] de 0 a X

Pour le coder c'est plus simple de faire une boucle du genre :

Code :

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

1
2
for(i=0;i<=n;i++)
    y+=x[i]*h[n-i]

Étant donné que le tableau Hn est fixe, et que celui des échantillons d’entrées se rempli au fur et a mesure, donc je ne fait que l’incrémenter a la lecture et au process, puis avec un modulo je le rend circulaire.

Enfin c'est ce que je faisais avant, maintenant je dois tout modifier pour virer les tableaux et ne faire que du pointeur, d’où le poste.

Mais bon si quelqu'un voit une solution meilleure je suis preneur

[souviron34]

Alors ce que tu veux faire serait plus quelque chose du genre :

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
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 ;
 
for (i=(taille-1);i>= 0;i--)
    Res = Res + (ptr[i] * x[taille-1-i]); }
 
return Res ;
}

[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

Mais sinon c'est ca ^^

[souviron34]

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

Pourquoi ?