Suche…


Einführung

C ++ hat wie C eine lange und abwechslungsreiche Geschichte in Bezug auf Kompilierungsworkflows und Buildprozesse. Heute verfügt C ++ über verschiedene gängige Build-Systeme, die zum Kompilieren von Programmen verwendet werden, manchmal für mehrere Plattformen innerhalb eines Build-Systems. Hier werden einige Build-Systeme überprüft und analysiert.

Bemerkungen

Derzeit gibt es kein universelles oder dominantes Buildsystem für C ++, das sowohl populär als auch plattformübergreifend ist. Es gibt jedoch mehrere wichtige Build-Systeme, die mit wichtigen Plattformen / Projekten verbunden sind, wobei GNU Make mit dem Betriebssystem GNU / Linux und NMAKE mit dem Projektsystem Visual C ++ / Visual Studio am bemerkenswertesten sind.

Darüber hinaus enthalten einige Integrated Development Environments (IDEs) spezielle Build-Systeme, die speziell für die native IDE verwendet werden. Bestimmte Buildsystemgeneratoren können diese systemeigenen IDE-Buildsystem- / Projektformate generieren, beispielsweise CMake für Eclipse und Microsoft Visual Studio 2012.

Build-Umgebung mit CMake erstellen

CMake generiert Build-Umgebungen für nahezu jeden Compiler oder IDE aus einer einzigen Projektdefinition. Die folgenden Beispiele zeigen, wie Sie eine CMake-Datei zum plattformübergreifenden C ++ - Code "Hello World" hinzufügen.

CMake-Dateien haben immer den Namen "CMakeLists.txt" und sollten bereits im Stammverzeichnis jedes Projekts (und möglicherweise auch in Unterverzeichnissen) vorhanden sein. Eine grundlegende CMakeLists.txt-Datei sieht folgendermaßen aus:

cmake_minimum_required(VERSION 2.4)

project(HelloWorld)

add_executable(HelloWorld main.cpp)

Sehen Sie live auf Coliru .

Diese Datei teilt CMake den Projektnamen, die zu erwartende Dateiversion und Anweisungen zum Generieren einer ausführbaren Datei mit dem Namen "HelloWorld" mit, die main.cpp erfordert.

Generieren Sie über die Befehlszeile eine Build-Umgebung für Ihren installierten Compiler / IDE:

> cmake .

Erstellen Sie die Anwendung mit:

> cmake --build .

Dies generiert die Standard-Build-Umgebung für das System, abhängig vom Betriebssystem und den installierten Tools. Halten Sie den Quellcode von Build-Artefakten mithilfe von Out-of-Source-Builds frei:

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

CMake kann auch die grundlegenden Befehle der Plattform-Shell vom vorherigen Beispiel abstrahieren:

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

CMake enthält Generatoren für eine Reihe allgemeiner Build-Tools und IDEs. So erstellen Sie Makefiles für nmake Visual Studio :

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

Kompilieren mit GNU make

Einführung

GNU Make (Styled make ) ist ein Programm zur Automatisierung der Ausführung von Shell-Befehlen. GNU Make ist ein spezifisches Programm, das unter die Make-Familie fällt. Make ist nach wie vor beliebt bei Unix- und POSIX-ähnlichen Betriebssystemen, einschließlich derjenigen, die vom Linux-Kernel, Mac OS X und BSD stammen.

GNU Make ist besonders bemerkenswert, weil es an das GNU-Projekt angeschlossen ist, das an das beliebte GNU / Linux-Betriebssystem angeschlossen ist. GNU Make hat auch kompatible Versionen, die auf verschiedenen Windows- und Mac OS X-Versionen laufen. Es ist auch eine sehr stabile Version mit historischer Bedeutung, die nach wie vor beliebt ist. Aus diesen Gründen wird GNU Make häufig neben C und C ++ unterrichtet.

Grundregeln

Erstellen Sie zum Kompilieren mit make ein Makefile in Ihrem Projektverzeichnis. Ihr Makefile kann so einfach sein wie:

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 [email protected] $(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)

HINWEIS: Stellen Sie absolut sicher, dass die Einrückungen mit einer Registerkarte und nicht mit vier Leerzeichen versehen sind. Andernfalls erhalten Sie eine Fehlermeldung mit Makefile:10: *** missing separator. Stop.

Führen Sie folgende Schritte aus, um dies über die Befehlszeile auszuführen:

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

$ ./app
Hello World!

$ make clean
$ ls
main.cpp  Makefile

Inkrementelle Builds

Wenn Sie anfangen, mehr Dateien zu haben, wird Make nützlicher. Was ist, wenn Sie a.cpp, aber nicht b.cpp bearbeitet haben ? Das Rekompilieren von b.cpp würde länger dauern.

Mit folgender Verzeichnisstruktur:

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

Das wäre ein gutes 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 [email protected] $(OBJS)

depend: .depend

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

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

include .depend

Beobachte wieder die Tabs. Dieses neue Makefile stellt sicher, dass Sie nur geänderte Dateien neu kompilieren, wodurch die Kompilierzeit minimiert wird.

Dokumentation

Weitere Informationen zu make finden Sie in der offiziellen Dokumentation der Free Software Foundation , der stackoverflow-Dokumentation und der ausführlichen Antwort von dmckee zu stackoverflow .

Bauen mit SCons

Sie können den plattformübergreifenden C ++ - Code "Hello World" mithilfe von Scons - Ein Python- Programmiersprache-Werkzeug erstellen .

Erstellen Sie zuerst eine Datei namens SConstruct (beachten Sie, dass SCons standardmäßig nach einer Datei mit genau diesem Namen sucht). Im hello.cpp sollte sich die Datei in einem Verzeichnis entlang Ihrer hello.cpp . Schreiben Sie die Zeile in die neue Datei

 Program('hello.cpp')

Führen scons nun vom Terminal aus scons . Sie sollten so etwas sehen

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

(Die Details können jedoch je nach Betriebssystem und installiertem Compiler variieren).

Die Klassen Environment und Glob helfen Ihnen bei der weiteren Konfiguration der Erstellung. ZB die SConstruct Datei

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

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

erstellt die ausführbare Datei hello und verwendet alle cpp Dateien in src . Sein CPPPATH ist /usr/include/boost und gibt den C ++ 11-Standard an.

Ninja

Einführung

Das Ninja-Build-System wird von seiner Projektwebsite als "kleines Build-System mit Fokus auf Geschwindigkeit" beschrieben. Ninja ist darauf ausgelegt, dass seine Dateien von Build-System-Dateigeneratoren generiert werden. Im Gegensatz zu Build-System-Managern auf höherer Ebene wie CMake oder Meson werden die Systeme auf untergeordneter Ebene erstellt.

Ninja ist hauptsächlich in C ++ und Python geschrieben und wurde als Alternative zum SCons-Buildsystem für das Chromium-Projekt erstellt.

NMAKE (Microsoft-Programmverwaltungsprogramm)

Einführung

NMAKE ist ein von Microsoft entwickeltes Befehlszeilenprogramm, das hauptsächlich in Verbindung mit Microsoft Visual Studio und / oder den Visual C ++ - Befehlszeilenprogrammen verwendet wird.

NMAKE ist ein Build-System, das unter die Make-Familie von Build-Systemen fällt, verfügt jedoch über bestimmte, von Unix-ähnlichen Make-Programmen abweichende Funktionen, z.

Autotools (GNU)

Einführung

Die Autotools sind eine Gruppe von Programmen, die ein GNU Build System für ein bestimmtes Softwarepaket erstellen. Es ist eine Reihe von Tools, die zusammenarbeiten, um verschiedene Build-Ressourcen zu erstellen, beispielsweise ein Makefile (zur Verwendung mit GNU Make). Autotools können somit als De-facto-Build-Systemgenerator betrachtet werden.

Einige bemerkenswerte Autotools-Programme umfassen:

  • Autoconf
  • Automake (nicht mit make verwechseln)

Im Allgemeinen soll Autotools das Unix-kompatible Skript und das Makefile generieren, damit der folgende Befehl (im einfachen Fall) die meisten Pakete erstellen und installieren kann:

./configure && make && make install

Daher hat Autotools auch eine Beziehung zu bestimmten Paketmanagern, insbesondere zu solchen, die an Betriebssysteme angeschlossen sind, die den POSIX-Standards entsprechen.



Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow