Usage des pointeurs dans les fonctions

Bonjour,

je cherche une explication à un problème de bon usage des pointeurs lors d'un appel de fonction C.

Voici mon code :

Code:

---

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

#include <stdio.h>   int entier;   int foo ( int *ptr ) { ptr = &entier; }   int main ( void ) { int *a; entier = 200; foo(a); printf("%d\n",*a); }

---

Dans le programme principal, je pensais qu'après l'appel de foo(), mon pointeur "a" prendrait l'adresse de la variable globale "entier". Il semblerait que non... Est ce que quelqu'un pourrait m'expliquer pourquoi ? Est ce que parce que passé ainsi, ce pointeur est en fait passé par valeur, ce qui empêche toute modification ?

Merci d'avance

Didou

Effectivement, après quelques ajouts permettant de visualiser les différentes adresses, voici la trace (et le code associé) :

Code:

---

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

#include <stdio.h>   int entier;   int foo ( int *ptr ) {   ptr = &entier; printf("Adresse pointée par ptr : %x\n",ptr); }   int main ( void ) {   int *a; printf("Adresse de la variable entier %x\n",&entier); entier = 200; foo(a); printf("Adresse pointée par a : %x\n",a); printf("entier = %d, *a = %d\n",entier,*a); }

---

La trace :
Adresse de la variable entier 80496b0
Adresse pointée par ptr : 80496b0
Adresse pointée par a : b7815ff4
entier = 200, *a = 1318268

Une explication ?

Il faut une double indirection.
Il faut passer comme parametre un pointeur sur le pointeur.

foo( int **ptr)

Arrivé par hasard sur le sujet je me permet de l'enrichir d'une question supplémentaire (surtout pour voir si j'ai compris).

Le code suivant serait-il équivalent à ce que propose fmdao ?

Code:

---

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

#include <stdio.h>   int entier;   int foo ( int *ptr ) { ptr = &entier; }   int main ( void ) { int a; entier = 200; foo(&a); printf("%d\n",a); }

---

Bonsoir.
C'est la fonction foo qui pose problème, donc... oui...
Du moins sur le fait qu'après l'appel de la fonction, la valeur pointée par/de a n'est pas celle d'entier.

La seule différence, c'est que dans le code de fmdao, a ne pointe sur aucune zone particulière (pointe n'importe où, en gros), et donc *a n'est pas forcément valide.

Ok mais, ce n'était pas la logique du premier programme.

int main ( void ) {
int *a;
entier = 200;
foo(a);
printf("%d\n",*a);
}


Voulait-il récupérer la valeur de a ou un pointeur sur un entier qui existe belle et bien puisque en globale ?

Je suis d'accord que dans l'absolu, c'est maladroit :cry:

Désolé transgohan, j'ai lu trop vite... :oops:
Ton code est plutôt équivalent à celui de didou31... :P
(Dans le sens où il ne fait pas ce qu'il lui demande... :D)

@fmdao Je pense qu'il voulait simplement que a pointe sur une variable globale...

Citation:

---

Envoyé par Steph_ng8

Désolé transgohan, j'ai lu trop vite... :oops:
Ton code est plutôt équivalent à celui de didou31... :P
(Dans le sens où il ne fait pas ce qu'il lui demande... :D)

---

Dans quel sens ? Le fait que je n'utilise pas un pointeur dans le main ? Ou bien que le changement ne sera pas pris en compte ? :calim2:

Le changement ne sera pas pris en compte.

En C, on passe forcément les paramètres par valeur, ce qui signifie que l'on peut utiliser la valeur de ce paramètre.
Ce parametre est comme une variable locale à la fonction qui disparaîtra au retour de la fonction.

Pour pouvoir modifier, un argument, il faut passer à la fonction l'adresse de l'argument :


- soit en lui donnant la valeur du pointeur :

void foo(int *pointeurSurUnEntier)
{
*pointeurSurUnEntier = 20;
}

main()
{
int a;
foo( &a); // argument = l'adresse de a qui va devenir un pointeur dans la fonction
// a a la même valeur que entier
}

- soit en faisant un passage par référence ( c'est mieux : pas de ces pointeurs de merde) :


void foo( int &referenceUnEntier)
{
referenceUnEntier = 20;
}

main()
{
int a;

foo ( a); // argument = une référence vers a
}

Citation:

---

Envoyé par fmdao

- soit en faisant un passage par référence ( c'est mieux : pas de ces pointeurs de merde) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

void foo( int &referenceUnEntier) { referenceUnEntier = 20; }   main() { int a;   foo ( a); // argument = une référence vers a }

---

---

Euh... c'est du C++, ça... :?

Merci pour vos différentes réponses. Je clarifie certains points et je poursuis la discussion :

- je développe effectivement en C et non en C++. Je ne peux donc pas utiliser un passage par variable tel que void foo ( int &referenceUnEntier ).

- je cherche effectivement à programmer une fonction qui me renvoie un pointeur sur un objet (ici un int) qui est en variable globale. Afin d'économiser de la mémoire, je cherche donc à ne pas dupliquer cet objet dans le main. La solution proposée par transgohan ne me convient pas puisque l'entier est créé dans le main en plus de la variable globale.

- si je comprends bien, dans mon code initial, le pointeur est passé par valeur, il ne peut donc pas être modifié (c'est bien basique mais ça m'avait échappé !). Je vois donc deux solutions pour résoudre mon problème :

o soit passer par un pointeur sur ce pointeur comme proposé par fmdao. Ça donne :

Code:

---

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

foo ( int **ptr ) {   *ptr = &entier; printf("Adresse pointée par ptr : %x\n",*ptr); }   main () {   int *a; printf("Adresse de la variable entier %x\n",&entier); entier = 200; foo ( &a ); printf("Adresse pointée par a : %x\n",a); printf("entier = %d, *a = %d\n",entier,*a); }

---

ça fonctionne, voici la trace :
Adresse de la variable entier 80496b0
Adresse pointée par ptr : 80496b0
Adresse pointée par a : 80496b0
entier = 200, *a = 200

o soit fournir le pointeur par le retour de la fonction :

Code:

---

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

int* foo () {   return &entier; }   main () {   int *a; printf("Adresse de la variable entier %x\n",&entier); entier = 200; a = foo ( ); printf("Adresse pointée par a : %x\n",a); printf("entier = %d, *a = %d\n",entier,*a); }

---

ça fonctionne aussi, voici la trace :
Adresse de la variable entier 8049670
Adresse pointée par a : 8049670
entier = 200, *a = 200

La première solution me permet d'utiliser un return pour gérer un retour de la fonction, ce qui n'est pas possible dans le second cas...

Merci pour vos contributions.

C'est bien ça. :)

Citation:

---

Envoyé par didou31

Afin d'économiser de la mémoire, je cherche donc à ne pas dupliquer cet objet dans le main.

---

À moins que ce soit un objet très gros (ou très complexe) ou que tu sois limité en mémoire, ce n'est pas nécessaire.

Citation:

---

Envoyé par didou31

La première solution me permet d'utiliser un return pour gérer un retour de la fonction, ce qui n'est pas possible dans le second cas...

---

Certes, mais je ne vois pas pourquoi tu pourrais avoir besoin d'utiliser la valeur de retour de la fonction... :?
Elle n'a aucune chance d'échouer, et je ne vois pas ce que tu pourrais renvoyer comme autre information.

Plutôt que d'utiliser une variable globale, tu peux utiliser une variable statique locale à la fonction.

Code:

---

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

int * f() { static entier = 200; return &entier; }   /*******************/   void f(int **ptr) { static entier = 200; *ptr = &entier; }

---

entier ne sera initialisée qu'au premier appel de f, donc ça correspond à ce que tu veux. ;)
Et puis, ça a l'avantage de ne pas utiliser de variable globale... (:roll:)
Par contre, s'il n'y a aucun moyen de l'initialiser en une seule instruction, ce n'est pas possible d'utiliser cette méthode. :(