gcc me dit :
In file included from systemprofile.c:1:
systemprofile.h:20: warning: 'struct n_list' declared inside parameter
list
systemprofile.h:20: warning: its scope is only this definition or
declaration, which is probably not what you want
systemprofile.c:70: warning: 'struct n_list' declared inside parameter
list
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Antoine Leca
En news:, unbewusst va escriure:
gcc me dit : In file included from systemprofile.c:1: systemprofile.h:20: warning: 'struct n_list' declared inside parameter list systemprofile.h:20: warning: its scope is only this definition or declaration, which is probably not what you want
Traduit en français, cela signifie que la construction
int f ( struct machin {int truc;} );
déclare bien une fonction f retournant un int et prenant un paramètre, mais le type de ce paramètre est inaccessible. En effet, la portée de la déclaration de la structure machin s'arrête... au niveau de la parenthèse fermante du prototype !
Et si par hasard tu écris plus loin
struct machin bidule;
ou
struct machin {int truc;} bidule;
tu vas définir une *nouvelle* structure ; et elle sera incompatible avec celle de la déclaration de fonction, donc écrire (en mode -ansi)
f(bidule);
va te retourner une erreur de compatibilité de type, incompréhensible pour ceux qui étaient habitués aux règles moins strictes qui précédaient la norme de 1990. GCC, dans sa grande mansuétude, previent les dits contrevenants du problème. La solution habituelle est de déplacer la définition du type structure avant le prototype, et faire que celui-ci se réduise à
int f ( struct machin );
Antoine
En news:1188031278.447562.123460@q5g2000prf.googlegroups.com,
unbewusst va escriure:
gcc me dit :
In file included from systemprofile.c:1:
systemprofile.h:20: warning: 'struct n_list' declared inside parameter
list
systemprofile.h:20: warning: its scope is only this definition or
declaration, which is probably not what you want
Traduit en français, cela signifie que la construction
int f ( struct machin {int truc;} );
déclare bien une fonction f retournant un int et prenant un paramètre, mais
le type de ce paramètre est inaccessible.
En effet, la portée de la déclaration de la structure machin s'arrête... au
niveau de la parenthèse fermante du prototype !
Et si par hasard tu écris plus loin
struct machin bidule;
ou
struct machin {int truc;} bidule;
tu vas définir une *nouvelle* structure ; et elle sera incompatible avec
celle de la déclaration de fonction, donc écrire (en mode -ansi)
f(bidule);
va te retourner une erreur de compatibilité de type, incompréhensible pour
ceux qui étaient habitués aux règles moins strictes qui précédaient la norme
de 1990.
GCC, dans sa grande mansuétude, previent les dits contrevenants du problème.
La solution habituelle est de déplacer la définition du type structure avant
le prototype, et faire que celui-ci se réduise à
gcc me dit : In file included from systemprofile.c:1: systemprofile.h:20: warning: 'struct n_list' declared inside parameter list systemprofile.h:20: warning: its scope is only this definition or declaration, which is probably not what you want
Traduit en français, cela signifie que la construction
int f ( struct machin {int truc;} );
déclare bien une fonction f retournant un int et prenant un paramètre, mais le type de ce paramètre est inaccessible. En effet, la portée de la déclaration de la structure machin s'arrête... au niveau de la parenthèse fermante du prototype !
Et si par hasard tu écris plus loin
struct machin bidule;
ou
struct machin {int truc;} bidule;
tu vas définir une *nouvelle* structure ; et elle sera incompatible avec celle de la déclaration de fonction, donc écrire (en mode -ansi)
f(bidule);
va te retourner une erreur de compatibilité de type, incompréhensible pour ceux qui étaient habitués aux règles moins strictes qui précédaient la norme de 1990. GCC, dans sa grande mansuétude, previent les dits contrevenants du problème. La solution habituelle est de déplacer la définition du type structure avant le prototype, et faire que celui-ci se réduise à
int f ( struct machin );
Antoine
espie
In article <fb3oji$a1e$, Antoine Leca wrote:
GCC, dans sa grande mansuétude, previent les dits contrevenants du problème. La solution habituelle est de déplacer la définition du type structure avant le prototype, et faire que celui-ci se réduise à
int f ( struct machin );
En pratique, ce que tu decris est rare. Il est peu frequent d'avoir en C des fonctions qui prennent des structures en parametre. Et effectivement, pour que le compilo ne rale pas, il faut que la definition de la structure soit visible.
Ce qui est bien plus frequent et utile, c'est d'avoir des fonctions qui prennent en parametre un pointeur sur une structure. Dans pas mal de cas, celui-ci peut etre vu comme un type abstrait (opaque) et on n'a aucun besoin de la definition de la structure.
Par contre, comme tu le signales, les regles de portee du C, interpretees a la lettre, conduisent a une creation locale de nom de structure lors d'un extern void f(struct machin *);
Il suffit alors de *declarer* la structure en question (pas besoin de definition) sur une portee plus globale (unite de compilation) pour s'assurer de la coherence avec toute definition ulterieure (y compris dans d'autres unites de compilation). C'est l'idiome classique:
struct machin; extern void f(struct machin *);
(similaire au classique des structures de donnees recursives: struct b { struct a *f; ... };
sauf que la, l'absence de declaration preliminaire n'est pas un probleme, puisque la definition de structure n'introduit pas de portee supplementaire).
In article <fb3oji$a1e$1@shakotay.alphanet.ch>,
Antoine Leca <root@localhost.invalid> wrote:
GCC, dans sa grande mansuétude, previent les dits contrevenants du problème.
La solution habituelle est de déplacer la définition du type structure avant
le prototype, et faire que celui-ci se réduise à
int f ( struct machin );
En pratique, ce que tu decris est rare. Il est peu frequent d'avoir en C
des fonctions qui prennent des structures en parametre. Et effectivement,
pour que le compilo ne rale pas, il faut que la definition de la structure
soit visible.
Ce qui est bien plus frequent et utile, c'est d'avoir des fonctions qui
prennent en parametre un pointeur sur une structure. Dans pas mal de cas,
celui-ci peut etre vu comme un type abstrait (opaque) et on n'a aucun
besoin de la definition de la structure.
Par contre, comme tu le signales, les regles de portee du C, interpretees
a la lettre, conduisent a une creation locale de nom de structure lors
d'un
extern void f(struct machin *);
Il suffit alors de *declarer* la structure en question (pas besoin de
definition) sur une portee plus globale (unite de compilation) pour
s'assurer de la coherence avec toute definition ulterieure (y compris dans
d'autres unites de compilation). C'est l'idiome classique:
struct machin;
extern void f(struct machin *);
(similaire au classique des structures de donnees recursives:
struct b {
struct a *f;
...
};
sauf que la, l'absence de declaration preliminaire n'est pas un probleme,
puisque la definition de structure n'introduit pas de portee supplementaire).
GCC, dans sa grande mansuétude, previent les dits contrevenants du problème. La solution habituelle est de déplacer la définition du type structure avant le prototype, et faire que celui-ci se réduise à
int f ( struct machin );
En pratique, ce que tu decris est rare. Il est peu frequent d'avoir en C des fonctions qui prennent des structures en parametre. Et effectivement, pour que le compilo ne rale pas, il faut que la definition de la structure soit visible.
Ce qui est bien plus frequent et utile, c'est d'avoir des fonctions qui prennent en parametre un pointeur sur une structure. Dans pas mal de cas, celui-ci peut etre vu comme un type abstrait (opaque) et on n'a aucun besoin de la definition de la structure.
Par contre, comme tu le signales, les regles de portee du C, interpretees a la lettre, conduisent a une creation locale de nom de structure lors d'un extern void f(struct machin *);
Il suffit alors de *declarer* la structure en question (pas besoin de definition) sur une portee plus globale (unite de compilation) pour s'assurer de la coherence avec toute definition ulterieure (y compris dans d'autres unites de compilation). C'est l'idiome classique:
struct machin; extern void f(struct machin *);
(similaire au classique des structures de donnees recursives: struct b { struct a *f; ... };
sauf que la, l'absence de declaration preliminaire n'est pas un probleme, puisque la definition de structure n'introduit pas de portee supplementaire).
