Définir une fonction avant le main?
Sont les déclarations de fonction/prototypes nécessaires en C99 ?
Je suis actuellement en train de définir mes fonctions dans un fichier d'en-tête et #include "-ING " dans le fichier principal. Est-ce OK en C99 ?
Pourquoi la plupart des programmeurs déclarer/prototype de la fonction avant le main() et de définir l'après main() ? N'est-il pas plus facile de les définir avant de principal et d'éviter toutes les déclarations et les prototypes ?
Contenu de l'en-tête.h fichier:
int foo(int foo)
{
//code
return 1;
}
Contenu du fichier principal:
#include <stdio.h>
#include "header.h"
int main(void)
{
foo(1);
return 0;
}
OriginalL'auteur Neeladri Vishweswaran | 2010-11-04
Vous devez vous connecter pour publier un commentaire.
Comment et où prototype et de définir une fonction en C :
Votre fonction est utilisée uniquement dans un lieu spécifique .fichier c :
Définir statique dans le .c fichier. La fonction ne sera visible et compilées pour ce fichier.
Votre fonction est utilisée dans de multiples .c fichiers :
Choisir un bon fichier c pour héberger votre définition (Tous les foo fonctions de foo.c fichier par exemple), et ont une fichier d'en-tête pour avoir tous les non-statique (que le public) fonctions prototypée. La fonction sera compilé une seule fois, mais visible pour tout fichier qui contient les fichiers d'en-tête. Tout va être mis en place au moment de la liaison. Amélioration Possible : toujours déclarer l'en-tête de fichier, le premier, a inclus dans son fichier c, de cette façon, vous serez sûr que n'importe quel fichier peut inclure en toute sécurité sans avoir besoin d'autres " comprend pour le faire fonctionner, référence : À grande Échelle les projets C++ (la Plupart des règles qui s'appliquent à C).
Votre fonction est inlinable (vous êtes sûr que c'est ?) :
Définir la fonction static inline dans un fichier d'en-tête. Le compilateur doit remplacer tout appel à votre fonction par la définition, si c'est possible (pensez macro-like).
La notion d'avant-après d'une autre fonction (votre fonction principale) dans c est seulement une affaire de style. Soit vous le faites :
Ou
résultat sera le même programme. La deuxième façon est préféré par les programmeurs parce que vous n'avez pas à réorganiser ou de déclarer de nouveaux prototypes à chaque fois que vous déclarez une nouvelle fonction que d'utiliser les autres. De Plus, vous obtenez une liste de toutes les fonctions déclarées dans le fichier. Il rend la vie plus facile dans le long terme pour vous et votre équipe.
static foo
'déclaration.h
fichier de définition dans.c
fichier?Non, je pense que vous obtenez un message d'erreur : "‘foo’ déclaré ‘statique’, mais jamais défini " pour chaque fichier votre en-tête. Pensez-statique en tant que "local". Il ne serait pas logique de faire de la publicité (à mettre dans un fichier d'en-tête) quelque chose comme locale à tout le monde, sauf si vous les fournissez de copie locale (inlining) à tout le monde.
OriginalL'auteur Matthieu
Habituellement, les gens le faire car c'est plus facile à faire avec des fichiers multiples. Si vous déclarez dans un en-tête, alors vous pouvez simplement #inclure cet en-tête n'importe où vous avez besoin de ces fonctions. Si vous définissez-les dans un en-tête et de l'inclure dans une autre unité de traduction, bang.
mais à l'aide d'une montre () sur des chiens et des fonctions statiques peuvent facilement vous protéger contre le bang. Vous pouvez même définir des fonctions dans les en-têtes. Pourquoi voudriez-vous faire cela, son dangereux (c'est) ? La plupart des compilateurs d'optimiser la façon de mieux le code des fonctions statiques. Le coût est temps de compilation et certains duplication de code si vous n'avez pas à aller tout le chemin (define tous d'un programme dans les en-têtes). Je suis actuellement en train de travailler sur un programme en C++ d'environ 40000 lignes de l'utilisation de ce style, fonctionne très bien pour moi.
OriginalL'auteur Puppy
Fonction déclarations sont nécessaires en C99. Fonction prototypes ne sont pas tenus en C99.
Déclarer les fonctions avant le point de les appeler et de les définir après le point de l'appel est une approche populaire pour structurer le code du programme. Cependant, ce n'est en aucune façon ce que le "plus" que les programmeurs n'. Au contraire, les plus populaires approche est de définir fonction avant le point du premier appel, auquel cas la déclaration séparée n'est pas nécessaire. Cette approche nécessite moins d'entretien, ce qui est pourquoi il est plus populaire que ce que vous décrivez.
Séparer les déclarations et les définitions sont normalement utilisés avec les fonctions externes, c'est a dire avec les fonctions utilisées dans plusieurs unités de traduction. Ces fonctions sont déclarées dans des fichiers d'en-tête et définis dans des fichiers de mise en œuvre.
OriginalL'auteur AnT
Vous ne devriez jamais définir
inline
fonctions de dans les en-têtes. Bien que vous pouvez avoirextern inline
fonctions, le cas habituel eststatic inline
.Règle de base pour les fichiers d'en-tête:
extern
static inline
extern
static const
C. Ross demandé, voici le raisonnement derrière cela: Une ressource de liaison externe ne doit jamais être défini qu'une seule fois[1]. Il s'ensuit que les définitions ne doivent pas résider dans les fichiers d'en-tête, qui sont destinés à être inclus dans plus d'un endroit.
Avoir
static
définitions dans les fichiers d'en-tête ne vous conduira pas à tous les problèmes, mais il est généralement mal vu, car le code doit être compilé plus d'une fois et seront présents dans les différents fichiers de l'objet, ce qui va augmenter la taille de l'exécutable (en supposant que l'éditeur de liens n'est pas assez intelligent pour comprendre la duplication de code).Le commun des exceptions à cette règle sont les constantes et les
inline
fonctions, qui sont censés être visible par le compilateur dans chaque unité de traduction à effectuer d'autres optimisations possibles.Remarque: [1] Cela ne s'applique pas à
inline
fonctions avec une liaison externe, mais comme c'est indéterminée qui de la, plusieurs définitions d'une fonction en ligne seront utilisés dans l'évaluation d'une fonction de désignation, ils sont la plupart du temps inutileUpvoted, mais je n'ai encore 2 questions. 1, Si je veux utiliser un
static void foo()
dans un programme, je suis censé mettrefoo
'déclaration dans le programme de.h
fichier ou.c
fichier? Je pose cette question parce que je suis confus, devrait.h
fichiers ne contientextern
fonctions qui peuvent être accédées par plusieurs.c
fichiers et pas seulement un? 2, j'ai appris que,inline
les fonctions doivent être définies dans.h
fichiers, alors pourquoi utiliser desstatic inline
? Lestatic
moyenne de la fonction inline ne sera visible que dans un.c
fichier?OriginalL'auteur Christoph
Votre approche est très bien pour les petits programmes. Fichiers d'en-tête sont conçus pour les déclarations et les définitions de constantes - ils fournir une interface pour le programme qu'ils "encapsuler". Les en-têtes sont conçus comme une interface pour d'autres unités de programme.
Dans le cas où vous avez plus .c fichiers, avant les déclarations et les fichiers d'en-tête sont nécessaires, car une fonction C peut être définie qu'une seule fois pour l'ensemble du programme (recherche d'une définition de la règle), même si vous pouvez utiliser la fonction de n'importe où (en tout .c fichier). Si vous en avez défini dans un en-tête, il serait inclus dans tous les .c les fichiers que vous utilisez et le résultat dans de multiples définitions.
quand quelque chose est bon, il est difficile de savoir que faire exactement le contraire n'est pas aussi bonne. Comme je l'ai dit dans le commentaire de DeadMG réponse, je ne définir des fonctions dans les en-têtes, non pas comme une habitude, mais aussi une optimisation de la tour et un style de programmation. Même idée que "les en-têtes des" classes C++, il est largement utilisé par de BOOST. Il serait probablement inutile si C ou C++ a un propre concept de modules compris par le compilateur (avant de liaison) comme les autres langues ont, au lieu de ces sanglantes de texte niveau comprend.
il peut faire sens en C++, en particulier avec les contraintes des modèles/méta-programmation (même si vous avez à considérer le temps de compilation des coûts comme vous l'avez dit), mais je ne vois pas l'avantage à en-tête de définition en C, sauf pour inline. Je suis d'accord que le fichier d'en-tête de construire est un "point faible" pour le c/c++.
OriginalL'auteur Karel Petranek
C'est plus rapide de faire comme ça, mais personnellement, je préfère avoir la fonction principale au début du fichier principal, et de mettre les autres fonctions dans d'autres fichiers ou en dessous de main.
Remarque que dans votre exemple, vous devriez éviter de déclarer foo() dans un fichier d'en-tête: vous ne serez pas en mesure de l'inclure dans deux fichiers sources différents. De le déclarer dans le fichier C contenant les principales(); vous n'aurez pas besoin de le définir ailleurs, sauf si vous faites référence à des de certains autres fichiers.
OriginalL'auteur peoro
Oui, il est plus facile de les définir avant d'principal. Si vous souhaitez utiliser ces fonctions, dans le dossier, un prototype n'est pas nécessaire. Dans ce cas toutefois, vous pouvez aussi ajouter le mot-clé "statique avant la définition de la fonction. (Dans le fichier C.) Qui va assurer la fonction n'est pas visible pour les autres fichiers. (Au moment de la liaison.)
Ne pas mettre de mots-clés statiques dans les fichiers à inclure.
hm, c'est pas ce que je voulais.
si vous utilisez classique C le style de programmation, les fonctions statiques ne doivent pas apparaître à tous les en-têtes.
OriginalL'auteur Prof. Falken
Vous devriez toujours prototype.
Les raisons de cette
méthodique de prototypage produit une liste sommaire dans les fichiers d'en-tête de l'fonctions dans le code, c'est très précieux pour les futurs lecteurs
en rien le meilleur des projets, beaucoup de fonctions ne seront pas avoir de la visibilité avant principal.
principal devrait être la première fonction de son dossier; il est plus facile pour le lecteur, car nous lisons vers le bas, pas vers le haut
Quand j'écris des bibliothèques, de la C des fichiers il y a un seul H de fichier, qui est interne à la bibliothèque, qui contient les prototypes (qui autrement serait statique, si tous les C les fichiers ont été réunis en un seul). Qui contient une liste de la bibliothèque-les fonctions privées. Concernant le fichier contenant les principales, je suis totalement d'accord.
OriginalL'auteur
Simplement parce que la plupart des humains lus de manière séquentielle. Commencer une histoire depuis le début, pas au milieu. Pas nécessaire, juste intuitive.
Bien sûr, si le code est prototypée dans une autre unité de compilation, les prototypes sont nécessaire.
OriginalL'auteur Clifford
Il est toujours une bonne pratique de déclarer les fonctions avant principal ou dans un fichier d'en-tête qui sera inclus dans les autres c des fichiers où nous avons utilisé cette fonction. En faisant cela, nous pouvons facilement identifier toutes les fonctions déclarées/défini .C ou .H fichiers. Et nous devrions utiliser le mot-clé extern avant de déclarer la fonction dans le fichier d'en-tête.
OriginalL'auteur Vijay Kumar