Les maquillages que j'ai traités, pour la plupart, sont complexes et cachent beaucoup de relations. Je n'en ai jamais écrit moi-même et je me demandais si quelqu'un avait des conseils sur la rédaction d'un maquillage facile à lire et à réutiliser?
4 Réponses :
Pour moi, la lecture qui m'a fait penser à ces problèmes, est le classique " Frappe récursive considérée comme nocive ".
Lorsque j'ai la chance de créer des maquillages à partir de zéro, j'essaie d'utiliser autant que possible des règles implicites, et de définir également des règles dans un fichier séparé, que je peux inclure du «vrai» Makefile.
Les défis avec l'utilisation de problèmes inhérents à problèmes qui ne font pas de "faute", mais proviennent de la mesure de l'utilisation pour appeler un autre processus. Soudain, nous avons une autre tâche à la main - communiquant entre deux ou plusieurs processus. Il est très facile de se perdre avec des variables d'environnement ou d'autres moyens de passer des informations. Les différences de plate-forme que font sont conçues pour se cacher, peuvent devenir visibles.
En toute honnêteté, la complexité d'un maquillage repose sur la complexité du programme. Si vous avez beaucoup de dossiers et de fichiers et de processus de compilation différents, votre fabricant sera probablement un peu long et compliqué. Si vous avez un programme Voici quelques conseils sur les fabricants de fabricants: http://mrbook.org/tatudials/make/ p> Voici un maquette très réutilisable qui n'est pas trop compliqué: p> helloworld code>, il n'y a aucune raison de dépasser quelques lignes plus longues que quelques lignes. CC=g++
CFLAGS=-c -Wall
LDFLAGS=
SOURCES=main.cpp hello.cpp factorial.cpp
OBJECTS=$(SOURCES:.cpp=.o)
EXECUTABLE=hello
all: $(SOURCES) $(EXECUTABLE)
$(EXECUTABLE): $(OBJECTS)
$(CC) $(LDFLAGS) $(OBJECTS) -o $@
.cpp.o:
$(CC) $(CFLAGS) $< -o $@
Vous avez raison, c'est très simple. Mais c'est parce que ça ne fait pas beaucoup. Dans un monde réel, vous allez vouloir un calcul de dépendance automatique, une génération de module récursive (ou non récursive, si vous lisez la réponse de @ AMIGABLE), des cibles de construction multiples, des objectifs de construction de tests, des cibles de la documentation, des répertoires distincts pour la source. , objets et binaires, etc. Une fois que vous incluez la mécanique pour tout cela, il ne sera plus simple, il sera bien plus difficile de lire et sera probablement bien moins réutilisable (parce que vous aurez construit dans le projet. connaissances spécifiques à elle).
Exactement. Plus le projet est compliqué, plus le maquillage est compliqué, pour toutes les circonstances générales.
+1 Oli. En outre, cela pourrait être beaucoup plus court. Je ne peux pas dire du sommet de ma tête, mais GNU fait des règles implicites, vous pouvez supprimer presque tout sauf les objets.
Comme dans, cc, cflags, sources, toutes ont des valeurs par défaut? Je ne savais pas que Wow!
@Amigable: D'accord. Toutefois: les règles implicites vont bien si vous avez des choses faciles comme bla.o: bla.c . Cependant, si vous avez bla.o: bla.c hdr1.h hdr2.h hdr3.h (ou pire, calcul de dépendance automatisé) ou obj / bla.o: src / bla .c , ils ne fonctionnent plus soudainement plus! (Bien que je sois encore beaucoup sur la courbe d'apprentissage pour faire, il y a peut-être donc des fonctionnalités pour aider avec cela.)
Par convention, CC est un compilateur C et CXX est un compilateur C ++. Réglage CC = G ++ demande des problèmes.
@Oli, je pense que GNU fait que GNU fasse beaucoup pittoresque à utiliser, mais je l'utilise toujours. Mon plan est d'utiliser Cmake à un moment donné, mais je ne m'en suis pas rentré.
Un didacticiel que j'ai trouvé utile pour comprendre les maquillages est http: //www.jfranken.de/homepages/johannes/vortraege/make_inhalt.en.html
Un autre conseil consiste à utiliser généreux d'expressions régulières pour les fichiers source et les dépendances
J'utilise habituellement quelque chose comme ceci, dans cet exemple, les fichiers source sont Ils dépendent tous sur Main.c File2.c File2.c File3.c File4.c Code>, pour ajouter plus que vous ajoutez simplement aux objets var. Makefile CODE>, donc pour une recompilation complète un simple Touch Makefile code> suffirait. P> PROGNAME = hi2u
LIBS = -ljpeg -ldirectfb -pthread
INCLUDES = -I/usr/local/include/directfb
LDFLAGS = -Llibs/
OBJECTS = main.o file2.o \
file3.o file4.o
CFLAGS = -W -Wall -O2 -ggdb
all: $(PROGNAME)
$(PROGNAME): $(OBJECTS)
gcc -o $(PROGNAME) $(OBJECTS) $(LIBS) $(INCLUDES) $(LDFLAGS)
$(OBJECTS): Makefile
.c.o:
gcc -c $(CFLAGS) $(INCLUDES) -o $@ $<
clean:
rm *.o $(PROGNAME)
IMO, il est pratiquement impossible d'écrire un maquillage facilement lisible ou réutilisable!
Tandis que hors du sujet, il y a beaucoup de vérité pour "utiliser cmake".
Et si vous ne voulez vraiment pas utiliser CMAKE, utilisez GNU FAIT.
-1: de la FAQ: "Vous ne devez demander que des questions pratiques et responsables en fonction des problèmes réels que vous rencontrez. Des questions bavardées et ouvertes diminuent l'utilité de notre site et poussent d'autres questions à la page d'accueil." J'ai aussi supprimé la balise
C : les fabricants ne sont pas limités à la programmation en C.Eriktous, je sais, mais cette question touche toujours quelque chose dont beaucoup d'entre nous ont été confrontés à plusieurs reprises. Bon vous avez supprimé la balise C.