C++
Systèmes de construction

Introduction

Remarques

Générer un environnement de construction avec CMake

CMake génère des environnements de construction pour presque tous les compilateurs ou IDE à partir d'une seule définition de projet. Les exemples suivants montreront comment ajouter un fichier CMake au code C ++ interplate -forme "Hello World" .

Les fichiers CMake sont toujours nommés "CMakeLists.txt" et devraient déjà exister dans le répertoire racine de chaque projet (et éventuellement dans les sous-répertoires). Un fichier CMakeLists.txt de base ressemble à ceci:

cmake_minimum_required(VERSION 2.4)

project(HelloWorld)

add_executable(HelloWorld main.cpp)

Voyez-le vivre sur Coliru .

Ce fichier indique à CMake le nom du projet, la version du fichier à attendre et les instructions pour générer un exécutable appelé "HelloWorld" nécessitant main.cpp .

Générez un environnement de compilation pour votre compilateur / IDE installé à partir de la ligne de commande:

> cmake .

Construisez l'application avec:

> cmake --build .

Cela génère l'environnement de génération par défaut pour le système, en fonction du système d'exploitation et des outils installés. Gardez le code source propre de tous les artefacts de construction avec l'utilisation des versions "out-of-source":

> mkdir build
> cd build
> cmake ..
> cmake --build .

CMake peut également abstraire les commandes de base du shell de plate-forme de l'exemple précédent:

> cmake -E make_directory build
> cmake -E chdir build cmake .. 
> cmake --build build 

CMake inclut des générateurs pour un certain nombre d'outils de construction et d'EDI courants. Pour générer des makefiles pour nmake Visual Studio :

> cmake -G "NMake Makefiles" ..
> nmake

Compiler avec GNU make

introduction

GNU Make (styled make ) est un programme dédié à l'automatisation de l'exécution des commandes shell. GNU Make est un programme spécifique de la famille Make. Make reste populaire parmi les systèmes d'exploitation de type Unix ou de type POSIX, y compris ceux dérivés du noyau Linux, Mac OS X et BSD.

GNU Make est particulièrement remarquable pour être associé au projet GNU, qui est attaché au système d’exploitation GNU / Linux. GNU Make dispose également de versions compatibles exécutant différentes versions de Windows et de Mac OS X. Il s’agit également d’une version très stable dont l’importance historique reste populaire. C'est pour ces raisons que GNU Make est souvent enseigné avec C et C ++.

Règles de base

Pour compiler avec make, créez un Makefile dans votre répertoire de projet. Votre Makefile peut être aussi simple que:

Makefile

# Set some variables to use in our command
# First, we set the compiler to be g++
CXX=g++

# Then, we say that we want to compile with g++'s recommended warnings and some extra ones.
CXXFLAGS=-Wall -Wextra -pedantic

# This will be the output file
EXE=app

SRCS=main.cpp

# When you call `make` at the command line, this "target" is called.
# The $(EXE) at the right says that the `all` target depends on the `$(EXE)` target.
# $(EXE) expands to be the content of the EXE variable
# Note: Because this is the first target, it becomes the default target if `make` is called without target
all: $(EXE)

# This is equivalent to saying
# app: $(SRCS)
# $(SRCS) can be separated, which means that this target would depend on each file.
# Note that this target has a "method body": the part indented by a tab (not four spaces).
# When we build this target, make will execute the command, which is:
# g++ -Wall -Wextra -pedantic -o app main.cpp
# I.E. Compile main.cpp with warnings, and output to the file ./app
$(EXE): $(SRCS)
    @$(CXX) $(CXXFLAGS) -o $@ $(SRCS)

# This target should reverse the `all` target. If you call
# make with an argument, like `make clean`, the corresponding target
# gets called.
clean:
    @rm -f $(EXE)

REMARQUE: Assurez-vous absolument que les indentations sont avec un onglet, pas avec quatre espaces. Sinon, vous aurez une erreur de Makefile:10: *** missing separator. Stop.

Pour l'exécuter depuis la ligne de commande, procédez comme suit:

$ cd ~/Path/to/project
$ make
$ ls
app  main.cpp  Makefile

$ ./app
Hello World!

$ make clean
$ ls
main.cpp  Makefile

Constructions incrémentielles

Lorsque vous commencez à avoir plus de fichiers, make devient plus utile. Et si vous modifiiez a.cpp mais pas b.cpp ? Recompiler b.cpp prendrait plus de temps.

Avec la structure de répertoires suivante:

.
+-- src
|   +-- a.cpp
|   +-- a.hpp
|   +-- b.cpp
|   +-- b.hpp
+-- Makefile

Ce serait un bon Makefile:

Makefile

CXX=g++
CXXFLAGS=-Wall -Wextra -pedantic
EXE=app

SRCS_GLOB=src/*.cpp
SRCS=$(wildcard $(SRCS_GLOB))
OBJS=$(SRCS:.cpp=.o)

all: $(EXE)

$(EXE): $(OBJS)
    @$(CXX) -o $@ $(OBJS)

depend: .depend

.depend: $(SRCS)
    @-rm -f ./.depend
    @$(CXX) $(CXXFLAGS) -MM $^>>./.depend

clean:
    -rm -f $(EXE)
    -rm $(OBJS)
    -rm *~
    -rm .depend

include .depend

Regardez à nouveau les onglets. Ce nouveau Makefile garantit que vous ne recompilez que les fichiers modifiés, minimisant ainsi le temps de compilation.

Documentation

Pour plus d'informations sur make, consultez la documentation officielle de la Free Software Foundation , la documentation de stackoverflow et la réponse élaborée de dmckee sur stackoverflow .

Construire avec des SCons

Vous pouvez créer le code C ++ "multiplateforme" "Hello World" , en utilisant Scons - Un outil de construction de logiciels en langage Python .

Tout d'abord, créez un fichier appelé SConstruct (notez que SCons recherchera un fichier avec ce nom exact par défaut). Pour l'instant, le fichier devrait être dans un répertoire tout au long de votre hello.cpp . Ecrire dans le nouveau fichier la ligne

 Program('hello.cpp')

Maintenant, à partir du terminal, lancez les scons . Vous devriez voir quelque chose comme

$ scons
scons: Reading SConscript files ...
scons: done reading SConscript files.
scons: Building targets ...
g++ -o hello.o -c hello.cpp
g++ -o hello hello.o
scons: done building targets.

(bien que les détails varient en fonction de votre système d'exploitation et du compilateur installé).

Les classes Environment et Glob vous aideront à configurer davantage les éléments à construire. Par exemple, le fichier SConstruct

env=Environment(CPPPATH='/usr/include/boost/',
    CPPDEFINES=[],
    LIBS=[],
    SCONS_CXX_STANDARD="c++11"
    )

env.Program('hello', Glob('src/*.cpp'))     

construit l'exécutable hello , en utilisant tous les fichiers cpp dans src . Son CPPPATH est /usr/include/boost et spécifie le standard C ++ 11.

Ninja

introduction

Le site Web de son projet décrit le système de construction Ninja comme «un petit système de construction axé sur la vitesse». Ninja est conçu pour que ses fichiers soient générés par des générateurs de fichiers système de génération, et adopte une approche de bas niveau pour créer des systèmes, contrairement aux gestionnaires de systèmes de génération de niveau supérieur comme CMake ou Meson.

Ninja est principalement écrit en C ++ et Python et a été créé comme alternative au système de construction SCons du projet Chromium.

NMAKE (utilitaire de maintenance de programme Microsoft)

introduction

NMAKE est un utilitaire de ligne de commande développé par Microsoft pour être utilisé principalement avec Microsoft Visual Studio et / ou les outils de ligne de commande Visual C ++.

NMAKE est un système de génération qui fait partie de la famille de systèmes de génération Make, mais possède certaines fonctionnalités distinctes des programmes Make de type Unix, comme la syntaxe de chemin de fichier spécifique à Windows (elle-même différente des chemins de fichier de style Unix).

Autotools (GNU)

introduction

Les Autotools sont un groupe de programmes qui créent un système de génération GNU pour un logiciel donné. C'est une suite d'outils qui fonctionnent ensemble pour produire diverses ressources de construction, telles qu'un fichier Makefile (à utiliser avec GNU Make). Autotools peut donc être considéré comme un générateur de système de facto.

Certains programmes Autotools notables incluent:

• Autoconf
• Automake (à ne pas confondre avec make )

En général, Autotools est conçu pour générer le script compatible Unix et Makefile pour permettre à la commande suivante de construire (ainsi que d'installer) la plupart des packages (dans le cas simple):

./configure && make && make install

En tant que tel, Autotools a également une relation avec certains gestionnaires de paquets, en particulier ceux qui sont attachés à des systèmes d'exploitation conformes aux normes POSIX.