Discussion :

[backdown]

bonjour,

Quelle est la meilleur manière de déclarer une fonction.

• Ecrire le prototype dans un fichier et l'inclure la source avec la directive #include
• Ecrire le prototype dans le meme fichier source du programme qui l'utilise
• Définir la fonction avant quelle ne soit appelée

Je pose cette question suite a une lecture de mon apprentissage dans le fondamentale du langage.

merci

[ram-0000]

Mon avis

Si la fonction est static (comprendre accessible uniquement par le source), ecrire le prototype en début du fichier source (après les éventuels include, define et autres typedef)

Si la fonction est extern (comprendre accessible par d'autres sources), ecrire le prototype dans le fichier include du source.

[ok.Idriss]

Bonjour.

Tout à fait d'accord avec cet avis. Après, rien n'empêche de mettre le prototype d'une fonction static dans un header, à condition qu'il soit inclus dans la source mais ça n'apporte rien et on se mélange ...

Tu peut aussi la définir avant qu'elle ne soit appellée quand elle est static. Pour les extern par contre, le mieux c'est de mettre le prototype dans le fichier.h.

@ +

[koala01]

Salut,

Je dirais qu'il n'y a pas vraiment de mauvaise manière de faire, selon la situation dans laquelle tu te trouve.

La seule chose qui est sure, c'est que, si tu va appeler ta fonction dans plusieurs modules d'un projet, il faudra la déclarer dans un fichier d'en-tête.

Pour le reste, tu peux envisager de ne pas déclarer une fonction dans un fichier d'en-tête si tu as la certitude que cette fonction ne sera appelée que par les fonctions qui se trouvent dans la même unité de compilation, ce qui apporte déjà une restriction majeure

Une autre restriction étant que les fonctions membres de classes ou de structures doivent être déclarées dans la définition de la classe

Cependant, cela peut arriver lorsque tu te trouve face à une fonction "kilométrique" que tu décide de factoriser, en sachant que seule la fonction d'origine sera réellement appelable.

Si, de manière quasi exceptionnelle, tu te trouve face à une situation dans laquelle il y a une fonction qui ne doit pas être déclarée dans un fichier d'en-tête, il faudra encore tenir compte du sens de lecture du compilateur pour déterminer s'il te faut placer une déclaration de la fonction ou non.

En effet, le compilateur va lire le fichier de haut en bas, et ne pas savoir, lorsqu'il en est à la ligne 9 (par exemple) ce qui se passe à la ligne 10.

Si, pour une raison ou une autre, il rencontre un symbole quelconque (le nom d'une fonction dans le cas qui nous occupe) qu'il n'a pas encore rencontré ne serait-ce que sous la forme d'une déclaration, tu va te faire jeter comme un malpropre.

Tu ne peux donc envisager de te passer de la déclaration d'une fonction que si tu as la certitude que toutes les fonctions qui pourront l'invoquer se trouvent plus bas dans le code.

Il faut aussi prendre en compte ce problème en ce qui concerne les fonctions qui seront invoquée par celle pour laquelle tu envisage de te passer de déclaration

En conclusion, nous pourrions dire que c'est faisable jusqu'à un certain point: en gros, tant que tu n'a pas des séries d'appels plus ou moins circulaires (A qui appelle B, qui appelle C, qui appelle... A).

De plus, cette pratique apporte une restriction de taille: tu te trouves face à l'obligation de garder un ordre précis dans la définition de tes fonctions.

Et, quoi qu'il en soit, imposer un tel ordre est de nature à apporter énormément de problèmes ne serait-ce que parce que tu risque toujours d'oublier que telle fonction doit impérativement être définie avant telle autre.

En définitive, je dirais qu'une fonction doit systématiquement être déclarée avant d'être définie:

• dans le fichier d'en-tête si elle doit être accessible en dehors de l'unité de compilation dans laquelle elle est définie
• juste après les différentes inclusions si elle ne doit être accessible qu'au départ des fonctions qui sont définies dans la même unité de compilation