C++
Bygg system

Introduktion

Anmärkningar

Genererar byggmiljö med CMake

CMake genererar byggmiljöer för nästan alla kompilatorer eller IDE från en enda projektdefinition. Följande exempel visar hur man lägger till en CMake-fil till korsplattformen "Hello World" C ++ -kod .

CMake-filer heter alltid "CMakeLists.txt" och bör redan existera i varje projekts rotkatalog (och eventuellt också i underkataloger.) En grundläggande CMakeLists.txt-fil ser ut som:

cmake_minimum_required(VERSION 2.4)

project(HelloWorld)

add_executable(HelloWorld main.cpp)

Se den live på Coliru .

Den här filen berättar för CMake projektnamnet, vilken filversion att förvänta sig och instruktioner för att generera en körbar kallad "HelloWorld" som kräver main.cpp .

Generera en byggmiljö för din installerade kompilator / IDE från kommandoraden:

> cmake .

Bygg applikationen med:

> cmake --build .

Detta genererar standardbyggnadsmiljön för systemet, beroende på operativsystemet och installerade verktyg. Håll källkoden ren från alla build-artefakter med användning av "out-of-source-builds":

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

CMake kan också abstrahera plattformsskalets grundläggande kommandon från föregående exempel:

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

CMake inkluderar generatorer för ett antal vanliga byggverktyg och IDE: er. Så här genererar du makefiler för Visual Studios nmake :

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

Kompilering med GNU-märke

Introduktion

GNU Make (styled make ) är ett program som är dedikerat till automatisering av att utföra skalkommandon. GNU Make är ett specifikt program som faller under Make-familjen. Make är fortfarande populärt bland Unix-liknande och POSIX-liknande operativsystem, inklusive de härledda från Linux-kärnan, Mac OS X och BSD.

GNU Make är särskilt anmärkningsvärt för att vara kopplad till GNU-projektet, som är anslutet till det populära GNU / Linux-operativsystemet. GNU Make har också kompatibla versioner som körs på olika smaker av Windows och Mac OS X. Det är också en mycket stabil version med historisk betydelse som förblir populär. Det är av dessa skäl som GNU Make ofta undervisas tillsammans med C och C ++.

Grundläggande regler

För att kompilera med märke, skapa en Makefile i din projektkatalog. Din Makefile kan vara så enkel som:

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)

OBS: Se till att indragningarna är med en flik, inte med fyra mellanslag. Annars får du ett fel i Makefile:10: *** missing separator. Stop.

Gör följande för att köra detta från kommandoraden:

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

$ ./app
Hello World!

$ make clean
$ ls
main.cpp  Makefile

Inkrementella byggnader

När du börjar ha fler filer blir mer användbart. Vad händer om du redigerade a.cpp men inte b.cpp ? Omkompilering av b.cpp skulle ta mer tid.

Med följande katalogstruktur:

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

Detta skulle vara en bra 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

Återigen titta på flikarna. Den här nya Makefile ser till att du bara kompilerar om ändrade filer, vilket minimerar kompileringstiden.

Dokumentation

För mer information om mer information , se den officiella dokumentationen från Free Software Foundation , stackoverflow-dokumentationen och dmckee's detaljerade svar på stackoverflow .

Byggnad med SCons

Du kan bygga korsplattformen "Hello World" C ++ -kod med hjälp av Scons - A Python- språk programvara konstruktionsverktyg.

SConstruct en fil som heter SConstruct (Observera att SCons kommer att leta efter en fil med detta exakta namn som standard). För tillfället bör filen finnas i en katalog längs hello.cpp . Skriv raden i den nya filen

 Program('hello.cpp')

scons från terminalen. Du borde se något liknande

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

(även om detaljerna kommer att variera beroende på operativsystem och installerad kompilator).

Klasserna Environment och Glob hjälper dig vidare att konfigurera vad du ska bygga. SConstruct filen

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

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

bygger det körbara hello med alla cpp filer i src . Dess CPPPATH är /usr/include/boost och den anger C ++ 11-standarden.

Ninja

Introduktion

Ninja build-systemet beskrivs av sin projektwebbplats som "ett litet build-system med fokus på hastighet." Ninja är utformad för att få sina filer genererade av build-systemfilgeneratorer och tar en låg nivå för att bygga system, i motsats till högre nivå-systemhanterare som CMake eller Meson.

Ninja är främst skriven i C ++ och Python och skapades som ett alternativ till SCons build-system för Chromium-projektet.

NMAKE (Microsoft Program Maintenance Utility)

Introduktion

NMAKE är ett kommandoradsverktyg som utvecklats av Microsoft för att främst användas tillsammans med Microsoft Visual Studio och / eller Visual C ++ kommandoradsverktyg.

NMAKE är ett build-system som faller under Make-familjen av build-system, men har vissa distinkta funktioner som skiljer sig från Unix-liknande Make-program, som att stödja Windows-specifik filvägsyntax (som i sig skiljer sig från Unix-stil-filvägar).

Autotools (GNU)

Introduktion

Autotools är en grupp program som skapar ett GNU Build-system för ett givet programvarupaket. Det är en svit med verktyg som arbetar tillsammans för att producera olika byggresurser, till exempel en Makefile (som ska användas med GNU Make). Således kan Autotools betraktas som en de facto build-systemgenerator.

Vissa anmärkningsvärda Autotools-program inkluderar:

• autoconf
• Automake (inte förväxlas med make )

Generellt är Autotools avsett att generera det Unix-kompatibla skriptet och Makefile för att låta följande kommando bygga (såväl som att installera) de flesta paket (i det enkla fallet):

./configure && make && make install

Som sådan har Autotools också en relation med vissa pakethanterare, särskilt de som är kopplade till operativsystem som överensstämmer med POSIX-standarden (er).