C++
Costruire sistemi

introduzione

Osservazioni

Generazione dell'ambiente di compilazione con CMake

CMake genera ambienti di compilazione per quasi tutti i compilatori o IDE da una singola definizione di progetto. I seguenti esempi mostreranno come aggiungere un file CMake al codice C ++ multipiattaforma "Hello World" .

I file CMake vengono sempre chiamati "CMakeLists.txt" e dovrebbero già esistere nella directory principale di ogni progetto (e possibilmente anche nelle sottodirectory). Un file CMakeLists.txt di base ha il seguente aspetto:

cmake_minimum_required(VERSION 2.4)

project(HelloWorld)

add_executable(HelloWorld main.cpp)

Guardalo dal vivo su Coliru .

Questo file indica a CMake il nome del progetto, quale versione del file aspettarsi e le istruzioni per generare un eseguibile chiamato "HelloWorld" che richiede main.cpp .

Generare un ambiente di compilazione per il compilatore / IDE installato dalla riga di comando:

> cmake .

Costruisci l'applicazione con:

> cmake --build .

Ciò genera l'ambiente di generazione predefinito per il sistema, a seconda del sistema operativo e degli strumenti installati. Mantieni il codice sorgente pulito da eventuali artefatti di build con l'uso di build "out-of-source":

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

CMake può anche astrarre i comandi di base della piattaforma shell dall'esempio precedente:

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

CMake include generatori per numerosi strumenti di sviluppo e IDE comuni. Per generare makefile per il nmake Visual Studio :

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

Compilare con GNU make

introduzione

GNU Make (styled make ) è un programma dedicato all'automazione dell'esecuzione dei comandi della shell. GNU Make è un programma specifico che rientra nella famiglia Make. Rendere popolare tra i sistemi operativi simil-Unix e POSIX, compresi quelli derivati ​​dal kernel Linux, Mac OS X e BSD.

GNU Make è particolarmente importante per essere collegato al Progetto GNU, che è collegato al popolare sistema operativo GNU / Linux. GNU Make ha anche versioni compatibili in esecuzione su vari gusti di Windows e Mac OS X. È anche una versione molto stabile con un significato storico che rimane popolare. È per questi motivi che GNU Make viene spesso insegnato insieme a C e C ++.

Regole di base

Per compilare con make, crea un Makefile nella directory del tuo progetto. Il tuo Makefile potrebbe essere semplice come:

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)

NOTA: assicurati che le rientranze siano con una linguetta, non con quattro spazi. Altrimenti, riceverai un errore di Makefile:10: *** missing separator. Stop.

Per eseguire ciò dalla riga di comando, effettuare le seguenti operazioni:

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

$ ./app
Hello World!

$ make clean
$ ls
main.cpp  Makefile

Build incrementali

Quando inizi ad avere più file, render diventa più utile. Cosa succede se hai modificato a.cpp ma non b.cpp ? La ricompilazione di b.cpp richiederebbe più tempo.

Con la seguente struttura di directory:

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

Questo sarebbe un buon 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

Di nuovo guarda le schede. Questo nuovo Makefile ti assicura di ricompilare solo i file modificati, riducendo al minimo il tempo di compilazione.

Documentazione

Per ulteriori informazioni, consultare la documentazione ufficiale della Free Software Foundation , la documentazione StackOverflow e la risposta elaborata di dmckee su StackOverflow .

Costruire con SCons

È possibile creare il codice C ++ multipiattaforma "Hello World" utilizzando Scons , uno strumento di costruzione di software in lingua Python .

Per prima cosa, crea un file chiamato SConstruct (nota che SCons cercherà un file con questo nome esatto per impostazione predefinita). Per ora, il file dovrebbe trovarsi in una directory proprio lungo il tuo hello.cpp . Scrivi nel nuovo file la riga

 Program('hello.cpp')

Ora, dal terminale, scons . Dovresti vedere qualcosa di simile

$ 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.

(anche se i dettagli varieranno a seconda del sistema operativo e del compilatore installato).

Le classi Environment e Glob ti aiuteranno a configurare ulteriormente cosa costruire. Ad esempio, il file di SConstruct

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

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

costruisce l'eseguibile hello , usando tutti i file cpp in src . Il suo CPPPATH è /usr/include/boost e specifica lo standard C ++ 11.

Ninja

introduzione

Il sistema di costruzione Ninja è descritto dal suo sito web del progetto come "un piccolo sistema di costruzione con un focus sulla velocità". Ninja è progettato per generare i file generati dai generatori di file di sistema e adotta un approccio a basso livello per la creazione di sistemi, in contrasto con i gestori di sistemi di generazione di livello superiore come CMake o Meson.

Ninja è scritto principalmente in C ++ e Python ed è stato creato come alternativa al sistema di build SCons per il progetto Chromium.

NMAKE (Utilità di manutenzione programma Microsoft)

introduzione

NMAKE è un'utilità da riga di comando sviluppata da Microsoft per essere utilizzata principalmente in combinazione con Microsoft Visual Studio e / o gli strumenti della riga di comando di Visual C ++.

NMAKE è un sistema di build che rientra nel sistema Make family of build, ma ha alcune caratteristiche distinte che si discostano dai programmi Make di Unix, come il supporto della sintassi del percorso del file specifico di Windows (che a sua volta differisce dai percorsi di file in stile Unix).

Autotools (GNU)

introduzione

Gli Autotools sono un gruppo di programmi che creano un sistema di generazione GNU per un determinato pacchetto software. È una suite di strumenti che lavorano insieme per produrre varie risorse di compilazione, come un Makefile (da utilizzare con GNU Make). Pertanto, gli Autotools possono essere considerati un generatore di sistemi di costruzione di fatto.

Alcuni programmi importanti di Autotools includono:

• autoconf
• Automake (da non confondere con make )

In generale, Autotools ha lo scopo di generare lo script compatibile con Unix e Makefile per consentire il seguente comando per compilare (oltre ad installare) la maggior parte dei pacchetti (nel caso semplice):

./configure && make && make install

Come tale, Autotools ha anche una relazione con alcuni gestori di pacchetti, specialmente quelli che sono collegati a sistemi operativi conformi agli standard POSIX.