terminologie : encore une question

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

Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:

| 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

En Xns949F888472012Zoupla@212.27.42.66, 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

Antoine Leca wrote:

En Xns949F888472012Zoupla@212.27.42.66, 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 ]
[ Laurent.Deniau@cern.ch - http://cern.ch/Laurent.Deniau ]
[ -- One becomes old when dreams become regrets -- ]

On 01 Mar 2004 12:27:27 GMT, Zouplaz <pouet@pouet.com> wrote:

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

In 'fr.comp.lang.c', Zouplaz <pouet@pouet.com> wrote:

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- emdelYOURBRA@noos.fr [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/

In 'fr.comp.lang.c', Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> wrote:

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- emdelYOURBRA@noos.fr [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/

In 'fr.comp.lang.c', "Antoine Leca" <root@localhost.gov> wrote:

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- emdelYOURBRA@noos.fr [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/

En c1vmj5$98h$1@sunnews.cern.ch, 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

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 : nicolas_aunai@hotmail.com