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
In article <g5g9k7$okq$, Xavier Roche wrote:
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.
In article <g5g9k7$okq$1@news.httrack.net>,
Xavier Roche <xroche@free.fr.NOSPAM.invalid> wrote:
nomail@gmail.com 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.
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.
--{ 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 <--
--{ 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:
tth@gally:/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; }
tth@gally:/tmp$ gcc -Wall kr.c
tth@gally:/tmp$
Là, c'est l'ancienne mode. Tout baigne. No problémo.
tth@gally:/tmp$ cat ansi.c
int fonction(int i, int j)
{ return i+ j; }
int main()
{ int a; a = fonction(0.33, "aaa"); return 0; }
tth@gally:/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
tth@gally:/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...
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
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
En news:dd492b39-34de-4ee8-a113-f4e1b563ce70@z72g2000hsb.googlegroups.com,
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.
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.
