fichier c ++ minimum pour linux

S’il s’agit d’un fichier unique, vous pouvez taper

make t 

Et il invoquera

 g++ t.cpp -ot 

Cela n’a même pas besoin d’un Makefile dans le répertoire, bien que cela devienne confus si vous avez un t.cpp, un tc et un t.java, etc.

Aussi un vrai Makefile:

 SOURCES := t.cpp # Objs are all the sources, with .cpp replaced by .o OBJS := $(SOURCES:.cpp=.o) all: t # Comstack the binary 't' by calling the comstackr with cflags, lflags, and any libs (if defined) and the list of objects. t: $(OBJS) $(CC) $(CFLAGS) -ot $(OBJS) $(LFLAGS) $(LIBS) # Get a .o from a .cpp by calling comstackr with cflags and includes (if defined) .cpp.o: $(CC) $(CFLAGS) $(INCLUDES) -c $< 

Voici un fichier makefile générique de mon répertoire d’extraits de code:

 SOURCES=$(wildcard *.cpp) OBJECTS=$(SOURCES:.cpp=.o) DEPS=$(SOURCES:.cpp=.d) BINS=$(SOURCES:.cpp=) CFLAGS+=-MMD CXXFLAGS+=-MMD all: $(BINS) .PHONY: clean clean: $(RM) $(OBJECTS) $(DEPS) $(BINS) -include $(DEPS) 

Tant que vous avez une source .cpp produisant un binary, vous n’avez besoin de rien de plus. Je ne l’ai utilisé qu’avec GNU make, et la génération de dépendances utilise la syntaxe gcc (également prise en charge par icc). Si vous utilisez les compilateurs SUN, vous devez remplacer “-MMD” par “-xMMD”. Assurez-vous également que la tabulation au début de la ligne après le clean: ne soit pas modifiée en espaces lorsque vous collez ce code ou que make vous donnera une erreur de séparateur manquante.

Avez-vous regardé SCons ?

Créez simplement un fichier SConstruct avec les éléments suivants:

 Program("t.cpp") 

Puis tapez:

 scons 

Terminé!

En supposant qu’aucun paramètre de configuration préconfiguré à l’échelle du système:

 CXX = g++ CPPFLAGS = # put pre-processor settings (-I, -D, etc) here CXXFLAGS = -Wall # put comstackr settings here LDFLAGS = # put linker settings here test: test.o $(CXX) -o $@ $(CXXFLAGS) $(LDFLAGS) test.o .cpp.o: $(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $< test.cpp: test.h 

Avez-vous regardé OMake ?

OMakeroot

 open build/C DefineCommandVars() .SUBDIRS: . 

OMakefile

 .DEFAULT: $(CXXProgram test, test) 

Ensuite, sous Linux ou Windows, tapez simplement:

 omake 

En bonus, vous obtenez automatiquement:

• construit parallèlement avec l’option -j (identique à make).
• Les sums de contrôle MD5 au lieu des horodatages (la construction devient résiliente aux échecs de synchronisation temporelle).
• Dépendances d’en-tête C / C ++ automatiques et précises.
• Dépendances inter-répertoires précises (quelque chose que make ne propose pas récursivement).
• Portabilité (1 chaîne de construction pour les gouverner tous, à l’abri des problèmes de style de chemin).
• Un vrai langage de programmation (meilleur que GNU make).

Un fichier GNU Makefile relativement petit, utilisant des règles prédéfinies et des repositorys automatiques:

 CC=c++ CXXFLAGS=-g -Wall -Wextra -MMD LDLIBS=-lm program: program.o sub.o clean: $(RM) *.o *.d program -include $(wildcard *.d) 

Quelques bonnes références sur la création d’un Makefile de base

http://en.wikipedia.org/wiki/Make_(software)

http://mrbook.org/tutorials/make/

http://www.opussoftware.com/tutorial/TutMakefile.htm

http://www.hsrl.rutgers.edu/ug/make_help.html

Le premier couple en particulier a un exemple minimal de Makefiles comme vous le décriviez. J’espère que cela pourra aider.

Construire avec l’option de débogage:

 env = Environment() if ARGUMENTS.get('debug', 0): env.Append(CCFLAGS = ' -g') env.Program( source = "template.cpp" ) 

Florin a un bon sharepoint départ. Je n’aimais pas gnu autoconf, alors j’ai commencé là-bas et ai poussé le concept plus loin en l’appelant MagicMakefile. J’en ai 3 versions du plus simple au plus complexe. La dernière en date est maintenant sur github: https://github.com/jdkoftinoff/magicmake

Fondamentalement, il suppose que vous avez une disposition standard pour les fichiers source de votre projet et utilise la fonction générique pour créer les règles de makefile à la volée. Ces règles sont ensuite évaluées. emballage.

[edit] À ce stade, j’utilise cmake pour tous mes projets car il génère des fichiers de projet utiles pour de nombreux systèmes de construction.

Jeff Koftinoff

Je cherchais ce à quoi pourrait ressembler un Makefile minimal autre que

 some_stuff: @echo "Hello World" 

Je sais que je suis en retard pour cette soirée, mais je pensais aussi lancer mon chapeau sur le ring. Ce qui suit est mon Makefile de projet de répertoire unique que j’ai utilisé pendant des années. Avec une petite modification, il utilise plusieurs répertoires (par exemple, src, obj, bin, en-tête, test, etc.). Suppose que tous les en-têtes et les fichiers source se trouvent dans le répertoire en cours. Et, doit donner au projet un nom qui est utilisé pour le nom binary en sortie.

 NAME = my_project FILES = $(shell basename -a $$(ls *.cpp) | sed 's/\.cpp//g') SRC = $(patsubst %, %.cpp, $(FILES)) OBJ = $(patsubst %, %.o, $(FILES)) HDR = $(patsubst %, -include %.h, $(FILES)) CXX = g++ -Wall %.o : %.cpp $(CXX) $(HDR) -c -o $@ $< build: $(OBJ) $(CXX) -o $(NAME) $(OBJ) clean: rm -vf $(NAME) $(OBJ) 

Si vos problèmes sont liés au fait que autoconf pense que le fichier .h est un fichier ac, essayez de le renommer en .hpp ou .h ++.