terminologie : encore une question

Le
Zouplaz
Bonjour, une fonction déclarée dans un fichier .h c'est :

- une déclaration de fonction
ou
- un prototype de fonction

De plus, peut-on dire que l'ensemble des fonctions déclarées dans le .h
sont "publiques" (c'est à dire connues donc utilisables par les autres
modules de l'application) ?

Merci
Vos réponses Page 1 / 2
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Marc Boyer
Le #581929
Zouplaz wrote:
Bonjour, une fonction déclarée dans un fichier .h c'est :
- une déclaration de fonction
ou
- un prototype de fonction


AMHA, les deux.

La VF de mon K&R parle de prototype, et assez peu de
déclaration.

J'aurais tendance à dire que "prototype" est le
terme général, en algorithmique, et qu'on peut écrire
le prototype de la fonction dans la doc qui présente
le code.

La notion de déclaration nous ammène plus proche
du C, et de ses règles de compilation.

Ainsi, dans le code:
void foo(); // Déclaration
void foo(){ printf("toto");} // Définition
mais si la deuxième ligne (celle avec le code)
n'était précédé d'aucune déclaration, ce serait
à la fois une déclaration et une définition (si je
me suis pas emmelé les pinceaux).

Par contre:
/* void foo(); */ est un prototype, pas une déclaration.

De plus, peut-on dire que l'ensemble des fonctions déclarées dans le .h
sont "publiques" (c'est à dire connues donc utilisables par les autres
modules de l'application) ?


Oui et non...
Rien n'oblige ton module a fournir la définition d'une
fonction qu'il déclare, dans le langage C. Mais il y a les
habitudes de programmation, et quand on déclare une fonctions,
on a l'habitude de la définir aussi.

Marc Boyer
--
Lying for having sex or lying for making war? Trust US presidents :-(

Gabriel Dos Reis
Le #581927
Marc Boyer
| Zouplaz wrote:
| > Bonjour, une fonction déclarée dans un fichier .h c'est :
| > - une déclaration de fonction
| > ou
| > - un prototype de fonction
|
| AMHA, les deux.

Non.

extern void f();

est une déclaration et non un prototype de fonction.

| La VF de mon K&R parle de prototype, et assez peu de
| déclaration.

Probablement parce que ses déclarations spécifient le nombre et le
type des paramètres et qu'il veut insister dessus.

| J'aurais tendance à dire que "prototype" est le
| terme général, en algorithmique, et qu'on peut écrire
| le prototype de la fonction dans la doc qui présente
| le code.

Je crois que tu es confusé.

« Prototype » en général fait référence à autre chose (surtout si tu
parles d'algorithmique et non de programmation en C).


| La notion de déclaration nous ammène plus proche
| du C, et de ses règles de compilation.

Bah non ! C'est plutôt le contraire je dirais.
La notion de déclaration est plus générale. Le C (ainsi que des
langages comme Perl et avatards où la notion de type est quelque peu
floue) a besoin de cette notion un peu oléolé justement à cause de
ses règles de compilation.

| Ainsi, dans le code:
| void foo(); // Déclaration
| void foo(){ printf("toto");} // Définition
| mais si la deuxième ligne (celle avec le code)
| n'était précédé d'aucune déclaration, ce serait
| à la fois une déclaration et une définition (si je
| me suis pas emmelé les pinceaux).
|
| Par contre:
| /* void foo(); */ est un prototype, pas une déclaration.

si tu viens du monde C++, tu ne connais probablement pas la différence
entre un prototype et une déclaration -- puisque dans ce monde, il n'y
a pas moyen de déclarer une fonction sans spécifier le nombre et le
type de ses paramètres.

Dans le monde C, il faut faire très attention.

6.2.1/2
[...]
(A function prototype is a declaration
of a function that declares the types of its parameters.)

En particulier, ce que tu montres ci-dessus, bien qu'étant une
déclaration, n'est pas un prototypage. I.e., tu as exactement le
contraire de ce qu'il faudrait.

-- Gaby
Antoine Leca
Le #581926
En , Zouplaz va escriure:
Bonjour, une fonction déclarée dans un fichier .h c'est :

- une déclaration de fonction
ou
- un prototype de fonction


Cela n'a rien à voir. Dans un .h, tu peux écrire ce que tu veux, des macros,
des définitions, des déclarations, etc.

Une déclaration (de fonction, de variable) dit comment utiliser quelque
chose ; pour une fonction, cela a la plupart du temps l'aspect d'un
prototype directement suivi de ";". On peut avoir autant de déclaration de
la même chose que l'on veut.

Une définition, qui doit être unique en règle générale, dit comment est fait
ce quelque chose. Pour une fonction, cela inclut le corps, écrit entre {
et }


De plus, peut-on dire que l'ensemble des fonctions déclarées dans le
.h sont "publiques" (c'est à dire connues donc utilisables par les
autres modules de l'application) ?


Non. Tu mélanges un aspect lié au langage (public par opposition à "privé",
indiqué par le mot clé static) avec un aspect qui relève de la méthodologie
(l'utilisation des .h). C te laisse toute liberté à ce sujet. Par contre, la
méthodologie que tu suis devrait être explicite à ce sujet. Mais ce n'est
plus ici qu'il faut poser la question... Saches cependant que l'on peut
distinguer entre les .h "publics" et les .h "privés"...


Antoine



Antoine

Laurent Deniau
Le #581925
Antoine Leca wrote:
En , Zouplaz va escriure:

Bonjour, une fonction déclarée dans un fichier .h c'est :

- une déclaration de fonction
ou
- un prototype de fonction



Cela n'a rien à voir. Dans un .h, tu peux écrire ce que tu veux, des macros,
des définitions, des déclarations, etc.

Une déclaration (de fonction, de variable) dit comment utiliser quelque
chose ; pour une fonction, cela a la plupart du temps l'aspect d'un
prototype directement suivi de ";". On peut avoir autant de déclaration de
la même chose que l'on veut.

Une définition, qui doit être unique en règle générale, dit comment est fait
ce quelque chose. Pour une fonction, cela inclut le corps, écrit entre {
et }


Il n'a pas demande la difference entre declaration et definition mais
entre declaration et prototype. La reponse a deja ete donnee par Gaby.

a+, ld.

--
[ Laurent Deniau -- Scientific Computing & Data Analysis ]
[ CERN -- European Center for Nuclear Research ]
[ - http://cern.ch/Laurent.Deniau ]
[ -- One becomes old when dreams become regrets -- ]


Horst Kraemer
Le #581923
On 01 Mar 2004 12:27:27 GMT, Zouplaz
Bonjour, une fonction déclarée dans un fichier .h c'est :

- une déclaration de fonction
ou
- un prototype de fonction


Ca dépend. Un prototype de fonction est une déclaration de fonction
qui déclare les types des paramètres.

int f(); /* déclaration de fonction sans prototype */

int f(void); /* prototype de fonction */
int f(int); /* prototype de fonction */

--
Horst

Emmanuel Delahaye
Le #581712
In 'fr.comp.lang.c', Zouplaz
Bonjour, une fonction déclarée dans un fichier .h c'est :

- une déclaration de fonction
ou
- un prototype de fonction


Ca dépend.

int fa(); /* declaration */
int fb(void); /* prototype separe */

De plus, peut-on dire que l'ensemble des fonctions déclarées dans le .h
sont "publiques" (c'est à dire connues donc utilisables par les autres
modules de l'application) ?


Une fonction définie sans 'static' peut être connue de n'importe quelle unité
de compilation. Elle n'est réellement connue que lorsqu'une déclaration (mais
il vaut mieux un prototype séparé) est placée dans le module. La
meilleure façon de le faire est évidemment d'inclure le header qui contient
les prototypes (ou déclarations) des fonctions. On peut techniquement se
passer des .h et mettre les prototypes à la main, mais c'est une pratique
détestable.

--
-ed- [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=cpp
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/

Emmanuel Delahaye
Le #581711
In 'fr.comp.lang.c', Marc Boyer
J'aurais tendance à dire que "prototype" est le
terme général, en algorithmique, et qu'on peut écrire
le prototype de la fonction dans la doc qui présente
le code.

La notion de déclaration nous ammène plus proche
du C, et de ses règles de compilation.

Ainsi, dans le code:
void foo(); // Déclaration


Oui.

void foo(){ printf("toto");} // Définition


Oui.

mais si la deuxième ligne (celle avec le code)
n'était précédé d'aucune déclaration, ce serait
à la fois une déclaration et une définition (si je
me suis pas emmelé les pinceaux).


Peu importe...

Par contre:
/* void foo(); */ est un prototype, pas une déclaration.


Non, c'est une declaration (commentée ! ;-) ), car il n'y a pas de paramètres
formels. C'est d'ailleurs ce que tu as écrit quelques lignes plus haut...

void foo(void);

est un prototype.

--
-ed- [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=cpp
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/

Emmanuel Delahaye
Le #581710
In 'fr.comp.lang.c', "Antoine Leca"
Saches
cependant que l'on peut distinguer entre les .h "publics" et les .h
"privés"...


Dans ce cas là je parle de .h 'interne [au bloc fonctionnel]' plutôt qui
'privé' (aka static) qui est limite la portée à une unité de compilation (et
qui ne necessite pas de .h, ni, em principe, de headers séparés.)

Mon code est organisé comme suit (Bloc fonctionnel XXX) :

En-têtes publics (XXX.h) :

/* macros ============================================================== */
/* constants =========================================================== */
/* types =============================================================== */
/* structures ========================================================== */
/* entry points ======================================================== */
/* public variables ==================================================== */

En-têtes internes (XXX_i.h) :

/* macros ============================================================== */
/* constants =========================================================== */
/* types =============================================================== */
/* structures ========================================================== */
/* internal public functions =========================================== */
/* internal public variables =========================================== */

Implementation (XXX_yyy.c) :

/* macros ============================================================== */
/* constants =========================================================== */
/* types =============================================================== */
/* structures ========================================================== */
/* private variables =================================================== */
/* private functions =================================================== */
/* internal public functions =========================================== */
/* internal public variables =========================================== */
/* entry points ======================================================== */
/* public variables ==================================================== */

Les 'entry points' sont visibles des autres applications
Les 'internal public functions' sont visibles des autres modules du bloc
fonctionnel, mais pas des autres applications.

--
-ed- [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=cpp
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/

Antoine Leca
Le #581709
En c1vmj5$98h$, Laurent Deniau va escriure:
Antoine Leca wrote:
Bonjour, une fonction déclarée dans un fichier .h c'est :
- une déclaration de fonction
ou
- un prototype de fonction


Cela n'a rien à voir. Dans un .h, tu peux écrire ce que tu veux, des
macros, des définitions, des déclarations, etc.


Il n'a pas demande la difference entre declaration et definition mais
entre declaration et prototype.


a) Il n'a pas demandé de différence entre les deux, mais de qualifier ce
qu'il y a dans un .h

b) Ce n'est pas parce qu'il ne l'a pas demandé que cette différence est
inintéressante

c) bizarrement, plusieurs réponses (indépendnants, cf. infra) sont les mêmes
que la mienne «ça dépend»


La reponse a deja ete donnee par Gaby.


Voui. Mais de la manière dont fonctionne les news, il m'est impossible de le
savoir. Parce que nous ne sommes pas sur le même serveur (bon, OK, je
pourrais améliorer mes feeds), et donc je n'ai pas encore vu la réponse de
Gabriel.


Antoine



Nicolas Aunai
Le #581708
Emmanuel Delahaye a présenté l'énoncé suivant :


Dans ce cas là je parle de .h 'interne [au bloc fonctionnel]' plutôt qui
'privé' (aka static) qui est limite la portée à une unité de compilation (et
qui ne necessite pas de .h, ni, em principe, de headers séparés.)

Mon code est organisé comme suit (Bloc fonctionnel XXX) :

En-têtes publics (XXX.h) :

/* macros ============================================================== */
/* constants =========================================================== */
/* types =============================================================== */
/* structures ========================================================== */
/* entry points ======================================================== */
/* public variables ==================================================== */

En-têtes internes (XXX_i.h) :

/* macros ============================================================== */
/* constants =========================================================== */
/* types =============================================================== */
/* structures ========================================================== */
/* internal public functions =========================================== */
/* internal public variables =========================================== */

Implementation (XXX_yyy.c) :

/* macros ============================================================== */
/* constants =========================================================== */
/* types =============================================================== */
/* structures ========================================================== */
/* private variables =================================================== */
/* private functions =================================================== */
/* internal public functions =========================================== */
/* internal public variables =========================================== */
/* entry points ======================================================== */
/* public variables ==================================================== */

Les 'entry points' sont visibles des autres applications
Les 'internal public functions' sont visibles des autres modules du bloc
fonctionnel, mais pas des autres applications.




tu es d'une incroyable rigueur dans tes codes... ça te dirais pas
d'enseigner le C à la fac ?

--
Nico,
http://astrosurf.com/nicoastro
messenger :

Publicité
Poster une réponse
Anonyme