C++
Systemen bouwen

Invoering

Opmerkingen

Build-omgeving genereren met CMake

CMake genereert buildomgevingen voor vrijwel elke compiler of IDE vanuit een enkele projectdefinitie. De volgende voorbeelden laten zien hoe u een CMake-bestand toevoegt aan de C ++ -code voor meerdere platforms "Hello World" .

CMake-bestanden hebben altijd de naam "CMakeLists.txt" en zouden al in de hoofdmap van elk project moeten voorkomen (en mogelijk ook in submappen.) Een eenvoudig CMakeLists.txt-bestand ziet er als volgt uit:

cmake_minimum_required(VERSION 2.4)

project(HelloWorld)

add_executable(HelloWorld main.cpp)

Zie het live op Coliru .

Dit bestand vertelt CMake de projectnaam, welke bestandsversie te verwachten is en instructies voor het genereren van een uitvoerbaar bestand genaamd "HelloWorld" waarvoor main.cpp vereist main.cpp .

Genereer een buildomgeving voor uw geïnstalleerde compiler / IDE vanaf de opdrachtregel:

> cmake .

Bouw de applicatie met:

> cmake --build .

Dit genereert de standaard buildomgeving voor het systeem, afhankelijk van het besturingssysteem en de geïnstalleerde tools. Houd broncode vrij van build-artefacten met behulp van "out-of-source" builds:

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

CMake kan ook de basisopdrachten van de platformshell abstraheren uit het vorige voorbeeld:

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

CMake bevat generators voor een aantal algemene build-tools en IDE's. Om makefiles voor het genereren van Visual Studio's nmake :

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

Compileren met GNU make

Invoering

De GNU Make (gestileerde make ) is een programma dat zich toelegt op de automatisering van het uitvoeren van shell-opdrachten. GNU Make is een specifiek programma dat valt onder de Make-familie. Maak blijft populair onder Unix-achtige en POSIX-achtige besturingssystemen, inclusief die afgeleid van de Linux-kernel, Mac OS X en BSD.

GNU Make is vooral opmerkelijk omdat het is gekoppeld aan het GNU-project, dat is gekoppeld aan het populaire GNU / Linux-besturingssysteem. GNU Make heeft ook compatibele versies die op verschillende smaken van Windows en Mac OS X draaien. Het is ook een zeer stabiele versie met historische betekenis die populair blijft. Het is om deze redenen dat GNU Make vaak wordt gegeven naast C en C ++.

Basisregels

Maak een Makefile in uw projectmap om te compileren met make. Uw Makefile kan zo simpel zijn als:

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)

OPMERKING: zorg er absoluut voor dat de inspringingen op een tab staan en niet op vier spaties. Anders krijg je een foutmelding van Makefile:10: *** missing separator. Stop.

Om dit vanaf de opdrachtregel uit te voeren, doet u het volgende:

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

$ ./app
Hello World!

$ make clean
$ ls
main.cpp  Makefile

Incrementele builds

Wanneer je meer bestanden begint te krijgen, wordt het nuttiger. Wat als u a.cpp hebt bewerkt maar niet b.cpp ? Het opnieuw compileren van b.cpp zou meer tijd kosten.

Met de volgende mapstructuur:

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

Dit zou een goede Makefile zijn:

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

Bekijk opnieuw de tabbladen. Deze nieuwe Makefile zorgt ervoor dat u alleen gewijzigde bestanden opnieuw compileert, waardoor de compilatietijd wordt geminimaliseerd.

Documentatie

Zie de officiële documentatie van de Free Software Foundation , de stackoverflow-documentatie en het uitgebreide antwoord van dmckee op stackoverflow voor meer informatie over make.

Bouwen met SCons

U kunt de platformoverschrijdende "Hello World" C ++ -code bouwen met behulp van Scons - een softwaretool voor de python- taal.

Maak eerst een bestand met de naam SConstruct (merk op dat SCons standaard naar een bestand met deze exacte naam zal zoeken). Voorlopig moet het bestand zich in een map direct langs uw hello.cpp . Schrijf in het nieuwe bestand de regel

 Program('hello.cpp')

Voer nu scons uit vanaf de terminal. Je zou zoiets moeten zien

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

(hoewel de details variëren, afhankelijk van uw besturingssysteem en geïnstalleerde compiler).

De klassen Environment en Glob helpen u verder te configureren wat u moet bouwen. Bijvoorbeeld het SConstruct bestand

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

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

bouwt het uitvoerbare hello , met alle cpp bestanden in src . Het CPPPATH is /usr/include/boost en specificeert de C ++ 11-standaard.

Ninja

Invoering

Het Ninja-buildsysteem wordt door de projectwebsite beschreven als "een klein buildsysteem met een focus op snelheid." Ninja is ontworpen om zijn bestanden te laten genereren door build-systeembestandsgeneratoren en hanteert een laag-niveau benadering voor het bouwen van systemen, in tegenstelling tot build-systeembeheerders op hoger niveau zoals CMake of Meson.

Ninja is voornamelijk geschreven in C ++ en Python en is gemaakt als alternatief voor het SCons build-systeem voor het Chromium-project.

NMAKE (Microsoft Program Maintenance Utility)

Invoering

NMAKE is een opdrachtregelprogramma ontwikkeld door Microsoft en wordt voornamelijk gebruikt in combinatie met Microsoft Visual Studio en / of de Visual C ++ opdrachtregelprogramma's.

NMAKE is een build-systeem dat valt onder de Make-familie van build-systemen, maar heeft bepaalde afzonderlijke functies die afwijken van Unix-achtige Make-programma's, zoals ondersteuning van Windows-specifieke bestandspadsyntaxis (die zelf verschilt van Unix-stijl bestandspaden).

Autotools (GNU)

Invoering

De Autotools zijn een groep programma's die een GNU Build-systeem maken voor een bepaald softwarepakket. Het is een pakket met tools die samenwerken om verschillende buildresources te produceren, zoals een Makefile (te gebruiken met GNU Make). Autotools kunnen dus worden beschouwd als een de facto gebouwde systeemgenerator.

Enkele opmerkelijke Autotools-programma's zijn onder meer:

• autoconf
• Automake (niet te verwarren met make )

Over het algemeen is Autotools bedoeld om het Unix-compatibele script en Makefile te genereren zodat de volgende opdracht de meeste pakketten kan bouwen (en installeren) (in het eenvoudige geval):

./configure && make && make install

Als zodanig heeft Autotools ook een relatie met bepaalde pakketbeheerders, met name die zijn gekoppeld aan besturingssystemen die voldoen aan de POSIX-norm (en).