pointeur sur une fonction

Bonjour,

étudiant au Cnam en informatique (études bac + 2) et ayant appris le java, je me suis mis au C depuis un mois par un livre. J'ai tenté de comprendre les principales différences entre le java et le C car je passe un concours IRTF en mai juin 2009 et on nous demande de savoir écrire en C. Je me donne donc 3-4 mois pour parvenir à savoir écrire en C, ayant déjà deux ans de programmation java derrière moi.

Mais voilà, je n'en reste pas moins un débutant en C, les notions de pointeurs sont nouvelles pour moi et je les découvre tout doucement.

Dans un des exercices du concours IRTF de 2007, on nous soumet le problème suivant:

Code:

---

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

Critiquez cet extrait de programme écrit en C:   int *adv() { int i; return (&i); }   main() { int *ia int b, c, d; ia = adv(); *ia = 0;

---

Quelques erreurs me paraissent évidentes:

- l'accolade de fin manquant pour main()
- return 0 manquant à la fin du main()
- b, c et d sont déclarés (donc l'espace mémoire adéquat leur est réservé) mais ils ne sont pas utilisés. On ne leur attribue pas de valeur.
- absence de ; après int *ia

Et après, je commence à bloquer.

Code:

---

1 2 3 4

int *adv() { int i; return (&i); }

---

doit renvoyer un int. Or, ici, c'est l'adresse d'un int qui est renvoyé.

Par contre, j'ai plein de questions:
- a t-on le droit d'écrire int *adv()? qu'est-ce que cela signifie?
- dans le main, que signifie chaque ligne?

Voici ce que je comprends:

Code:

---

1 2 3 4 5 6

main() { int *ia; /* pointeur ia déclaré*/ int b, c, d; /* déclaration de 3 variables */ ia = adv(); /* le pointeur pointe sur la fonction adv() */ *ia = 0; /* on attribue au pointeur ia la valeur 0*/ return 0; /* OK */}

---

Au final, comment ce programme peut être critiqué?

Merci par avance pour votre aide,
Johnny

Citation:

---

Code:

---

1 2 3 4

int *adv() { int i; return (&i); }

---

doit renvoyer un int. Or, ici, c'est l'adresse d'un int qui est renvoyé.

---

Non, la fonction doit renvoyer un int*, c'est à dire l'adresse d'un int.
(le type adresse d'un int s'écrit int*, prendre l'adresse d'une variable (par exemple i) s'écrit &i)

Cette fonction est fausse, non pas à cause des types, mais parce qu'elle renvoie l'adresse d'une variable locale (i). Or une variable locale est détruite en sortie de la fonction et on a renvoyé l'adresse de quelque chose qui n'existe plus. On ne doit jamais renvoyer de quelque manière que ce soit l'adresse d'une variable locale.

Autre critique, int *adv() n'est pas un prototype. Il serait préférable d'écrire

Code:

---

int *adv(void)

---

De même, il est souhaitable de ne pas utiliser des comportements par défaut et d'écrire explicitement

Code:

---

int main(void)

---

Code:

---

ia = adv(); /* le pointeur pointe sur la fonction adv() */

---

Non, le pointeur ia prend la valeur retournée par la fonction adv()

Code:

---

*ia = 0; /* on attribue au pointeur ia la valeur 0*/

---

Non, sinon on aurait écrit ia = 0 (ou plutôt ia = NULL)
Ceci signifie que le contenu de l'adresse ia (*ia) est mis à 0 (Ce qui fera planter puisque ia contient l'adresse d'une variable locale détruite)

Merci beaucoup pour cette réponse rapide qui m'aide à commencer à y voir un peu plus clair sur le C.

Par contre, je ne comprends pas

Citation:

---

Citation:

---

Citation:
Code :

int *adv() {
int i;
return (&i);
}

doit renvoyer un int. Or, ici, c'est l'adresse d'un int qui est renvoyé.

---

Non, la fonction doit renvoyer un int*, c'est à dire l'adresse d'un int.
(le type adresse d'un int s'écrit int*, prendre l'adresse d'une variable (par exemple i) s'écrit &i)

---

Comment doit-on alors écrire cette fonction si on doit retourner l'adresse d'un int?

En fait, je ne comprends pas pourquoi la version proposée est fausse puisqu'on retourne l'adresse de i, qui est un int, et qu'il faut que la fonction retourne l'adresse d'un int.

Ou alors, je crois comprendre. Dans la syntaxe, cette partie du programme n'est pas fausse car elle renvoie l'adresse d'un int, comme elle doit le faire. Cependant, comme vous dites, " On ne doit jamais renvoyer de quelque manière que ce soit l'adresse d'une variable locale."

Aurait-il mieux valu écrire:

Code:

---

1 2 3

int adv(int i) { return i; }

---

?

Une seconde question: comment savait-on que l'on devait retourner l'adresse d'un int et non pas un int?

Je pose la question car, en java, quand on écrit quelque chose du style int adv(), la fonction doit renvoyer un int car elle est du type int.

Merci par avance,
Johnny

Citation:

---

Comment doit-on alors écrire cette fonction si on doit retourner l'adresse d'un int?

---

int * adv(void)

Citation:

---

Ou alors, je crois comprendre. Dans la syntaxe, cette partie du programme n'est pas fausse car elle renvoie l'adresse d'un int, comme elle doit le faire. Cependant, comme vous dites, " On ne doit jamais renvoyer de quelque manière que ce soit l'adresse d'une variable locale."

---

Oui, la syntaxe est correcte, mais la valeur retournée n'a pas de sens

Citation:

---

Une seconde question: comment savait-on que l'on devait retourner l'adresse d'un int et non pas un int?

---

parce qu'on avait int * adv(...) et non pas int adv(...)

Citation:

---

Je pose la question car, en java, quand on écrit quelque chose du style int adv(), la fonction doit renvoyer un int car elle est du type int.

---

Le principe est le même.

Pour compléter :

- Le type "adresse de int" s'écrit int *
Donc déclarer une variable p de ce type (pointeur sur int) s'écrit

Code:

---

int * p;

---

ce qui se lit comme p est un int * (adresse de int) ou *p est un int. C'est pourquoi, si je veux le int dont l'adresse est p, j'écris *p (un int)

- Prendre l'adresse d'un objet i de type int s'écrit &i. &i est donc une valeur de type int *.
En conséquence, *&i est identique à i

ouf... merci pour toutes ces précisions.

En fait, donc mon livre d'apprentissage du C, je n'ai pas croisé int * p, seulement des choses du type:
char str[] = "Bonjour";
char ptr_str*;
ptr_str = malloc (strlen(str) + 1);

mais jamais quelque chose du style int * p.

Je pensais avoir vu une bonne partie des pointeurs en lisant le tutoriel sur les pointeurs de C/C++ du forum.

Merci beaucoup pour l'explication. C'est plus clair.

Citation:

---

Envoyé par johnny3

char ptr_str*;

---

Cela m'étonnerai que tu ais vu cela dans ton livre, ou alors, jète le (loin), la syntaxe n'est pas correcte.

désolé, c'était la fatigue:

Code:

---

1 2 3

char str[] = "Bonjour"; char *ptr_str; ptr_str = malloc (strlen(str) + 1);

---

(c'est pas complètement précis, mais pour débuter, simplifions la chose).
On peut dire que dans un programme tu as deux zones mémoires distinctes : la pile et le tas.
La pile contient tes variables locales. La zone pour une variable locale est réservée quand tu déclare cette variable et est libérée quand la variable sort de sa portée (sortie de la fonction) :

Code:

---

1 2 3 4 5 6 7 8 9

void ma_fonction(void) { int a;/* on réserve ici sur la pile l'espace mémoire pour a */ int *pa = &a; /* pa pointe sur l'adresse de a, qui est valide ici.*/ /* .... */ }/* En sortant de la fonction, la mémoire pour a est 'libérée', on ne peut plus écrire à cet emplacement.

---

Donc en reprenant ton exercice :

Code:

---

1 2 3 4 5 6

int *adv(void) { int i; /* on réserve un espace mémoire pour la variable i*/ return (&i); /* on retourne l'adresse de i */ }/* on libère l'espace mémoire réservé pour i -> conclusion l'adresse retournée désigne une zone mémoire dans laquelle on ne devrait plus écrire */

---

En général, les réservations et libérations sur la pile sont automatique, tu n'a rien à écrire pour cela.

Le tas te permet de réserver explicitement une zone mémoire .... mais au prix de devoir la libérer aussi de façon explicite. Ce sont les fonctions malloc/free :

Code:

---

1 2 3 4 5 6 7

int pi* = malloc(sizeof(int));/* tu demande à réserver un espace mémoire suffisant pour contenir un int*/ if(pi!=NULL){/*on teste si le malloc a réussi !*/ *pi = 4; /* on écrit une valeur dans cette zone réservée*/ /* ... */ free(pi);/* quand on en n'a plus besoin, on libère cet espace. */ }

---

Le danger dans cette gestion dynamique de la mémoire est l'oubli du free dès qu'on en n'a plus besoin. La mémoire n'est pas rendu disponible et si on fait beaucoup de malloc et jamais de free, on se retrouve à un moment sans plus de mémoire disponible. C'est ce qu'on appelle une fuite mémoire.

Citation:

---

Envoyé par 3DArchi

si on fait beaucoup de malloc et jamais de free, on se retrouve à un moment sans plus de mémoire disponible. C'est ce qu'on appelle une fuite mémoire.

---

;)

pas tout à fait..

Le comportement que tu décris s'appelle "un bouffeur de mémoire" :P

Une fuite de mémoire serait de ré-utiliser un pointeur pour y stocker une allocation sans avoir préalablement libéré la mémoire pointée et précedemment allouée..
:D

merci à tout le monde pour ces réponses précises.