Format de declarations dans une fonction

Le
nomail
Salut,

je voudrais comprendre quelle(s) difference y a t il entre ces deux
types de declarations:
int fonction(i, h)
int i;
int j:
{
return int;
}

et

int fonction(int i, int j) {
return int;
}

par ailleurs, il y a quelque temps j'ai vu passer un tool sur Unix qui
permet de passer d'une declaration a une autre, mais j'ai oublie son
nom

Merci
Fred
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Xavier Roche
Le #16324841
a écrit :
int fonction(i, h)
int i;
int j:
{



Vieille (de mémoire, K&R) notation, un peu passée de mode. Aucune
différence avec la "nouvelle" (ansi C, toujours de mémoire)
espie
Le #16326561
In article Xavier Roche
a écrit :
int fonction(i, h)
int i;
int j:
{



Vieille (de mémoire, K&R) notation, un peu passée de mode. Aucune
différence avec la "nouvelle" (ansi C, toujours de mémoire)



Dans ce cas precis, non, pas de difference. Dans la realite, il y *a* des
differences, et elles sont particulierement traitres.

Typiquement, si on a une fonction declaree en K&R telle que:
int
f(c, i)
char c;
int i;
{
}

Le prototype correspondant n'est *pas*
int f(char c, int i);

en effet, en K&R, il n'y a pas de `prototypes', et donc les arguments sont
systematiquement promus avant d'etre passes a une fonction. Il n'y a par
exemple pas de facon de passer directement un char ou un short a une fonction.

Si on ecrit
int
f(c, i)
char c;
int i;
{
}
ca veut dire qu'on recupere un parametre passe a la fonction dans une variable
locale char.


La traduction moderne serait plutot:
int
f(int c_, int i)
{
char c = c_;
}


et non, ca n'est malheureusement pas du tout du point de detail.

Il y a un outil qui fait la conversion livre avec au moins certaines
versions de gcc. Il s'appelle protoize/unprotoize.
Thierry B.
Le #16326781
--{ Xavier Roche a plopé ceci: }--

int fonction(i, h)
int i;
int j:
{



Vieille (de mémoire, K&R) notation, un peu passée de mode. Aucune
différence avec la "nouvelle" (ansi C, toujours de mémoire)



Mmmmm, pas si sur... Avec la déclaration K&R de fonction, tu
vas renoncer à un certain nombre de contrôles de validité sur
les paramêtres. En première approximation, hein, je ne suis
pas un guru des normes du C. Démo:

:/tmp$ cat kr.c
int fonction(i, j)
int i; int j;
{ return i+ j; }
int main()
{ int a; a = fonction(0.33, "aaa"); return 0; }
:/tmp$ gcc -Wall kr.c
:/tmp$

Là, c'est l'ancienne mode. Tout baigne. No problémo.

:/tmp$ cat ansi.c
int fonction(int i, int j)
{ return i+ j; }
int main()
{ int a; a = fonction(0.33, "aaa"); return 0; }
:/tmp$ gcc -Wall ansi.c
ansi.c: In function 'main':
ansi.c:4: warning: passing argument 2 of 'fonction' makes integer from
pointer without a cast
:/tmp$

Et là, on a la nouvelle mouture. Astalavista Baby.


Quand à la conversion ansi -> K&R, j'en avais trouvé un il y a
quelques mois, et sjmsb, c'était dans le tarball de la libjpeg
ou de ghostscript. Bonne chance...


--
--> http://la.buvette.org/POV/ex/ex33.html <--
Antoine Leca
Le #16329811
En news:,
Fred va escriure:
je voudrais comprendre quelle(s) difference y a t il entre ces deux
types de declarations:
int fonction(i, h) int i; int j:
{ return i; }

et

int fonction(int i, int j) { return i; }



[ J'ai corrrigé l'instruction return i au lieu de return int. ]

Dans le second cas (avec prototype, c'est ainsi que l'on nomme cette
formulation avec le type suivi du nom du paramètre le tout dans une liste
entre parenthèses), pour chaque appel à fonction _après_ le code, le
compilateur va vérifier le nombre de paramètres qui doit être 2, et va
convertir le cas échéant les expressions passées en argument vers int.

Cette forme d'écriture est instamment recommandée.


Dans le premier cas (pas de protototype), le compilateur ne fait aucun
contrôle sur les arguments que tu passes comme paramètre, ni en nombre ni en
type. Et à l'appel fonction(x,y), il ne fait aucune conversion des
expressions x et y en int.

À l'intérieur du code de fonction, le compilateur va considérer que h (que
tu n'as pas déclaré explicitement) est un int ; et donc va probablement
émettre des avertissements pour te signaler que h et j sont déclarés mais
non utilisés.

Cette forme d'écriture est à éviter (et suscite normalement d'autres
avertissements de la part du compilateur).



par ailleurs, il y a quelque temps j'ai vu passer un tool sur Unix qui
permet de passer d'une declaration a une autre, mais j'ai oublie son
nom...



Il y en a plusieurs, [un]prototize cité mais aussi proto, cproto, unproto et
j'en oublie sûrement.


Antoine
Publicité
Poster une réponse
Anonyme