Discussion :

[johnny3]

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 :

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

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 :

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

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 :

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

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

[diogene]

Code :

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

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 :

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

int *adv(void)

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

Code :

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

int main(void)

Code :

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

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

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

Code :

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

	*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)

[johnny3]

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:
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 :

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

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

[diogene]

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

int * adv(void)

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

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(...)

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 :

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

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

[johnny3]

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.

[ram-0000]

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.