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) ?
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) ?
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) ?
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) ?
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) ?
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) ?
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 }
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 }
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 }
Bonjour, une fonction déclarée dans un fichier .h c'est :
- une déclaration de fonction
ou
- un prototype de fonction
Bonjour, une fonction déclarée dans un fichier .h c'est :
- une déclaration de fonction
ou
- un prototype de fonction
Bonjour, une fonction déclarée dans un fichier .h c'est :
- une déclaration de fonction
ou
- un prototype de fonction
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) ?
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) ?
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) ?
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.
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.
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.
Saches
cependant que l'on peut distinguer entre les .h "publics" et les .h
"privés"...
Saches
cependant que l'on peut distinguer entre les .h "publics" et les .h
"privés"...
Saches
cependant que l'on peut distinguer entre les .h "publics" et les .h
"privés"...
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.
La reponse a deja ete donnee par Gaby.
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.
La reponse a deja ete donnee par Gaby.
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.
La reponse a deja ete donnee par Gaby.
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.
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.
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.