C++
Buduj systemy

Wprowadzenie

Uwagi

Generowanie środowiska budowania za pomocą CMake

CMake generuje środowiska kompilacji dla prawie dowolnego kompilatora lub IDE z jednej definicji projektu. Poniższe przykłady pokażą, jak dodać plik CMake do wieloplatformowego kodu C ++ „Hello World” .

Pliki CMake są zawsze nazywane „CMakeLists.txt” i powinny już istnieć w katalogu głównym każdego projektu (i ewentualnie również w podkatalogach.) Podstawowy plik CMakeLists.txt wygląda następująco:

cmake_minimum_required(VERSION 2.4)

project(HelloWorld)

add_executable(HelloWorld main.cpp)

Zobacz na żywo na Coliru .

Ten plik informuje CMake nazwę projektu, jakiej wersji pliku się spodziewać, oraz instrukcje dotyczące generowania pliku wykonywalnego o nazwie „HelloWorld”, który wymaga main.cpp .

Wygeneruj środowisko kompilacji dla zainstalowanego kompilatora / IDE z wiersza poleceń:

> cmake .

Zbuduj aplikację za pomocą:

> cmake --build .

Generuje to domyślne środowisko kompilacji dla systemu, w zależności od systemu operacyjnego i zainstalowanych narzędzi. Utrzymuj kod źródłowy w czystości od wszelkich artefaktów kompilacji dzięki kompilacjom „spoza źródła”:

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

CMake może również wyodrębnić podstawowe polecenia powłoki platformy z poprzedniego przykładu:

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

CMake zawiera generatory wielu popularnych narzędzi do budowania i IDE. Aby wygenerować pliki makefile dla nmake Visual Studio :

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

Kompilacja z marką GNU

Wprowadzenie

GNU Make (stylizowany make ) to program dedykowany do automatyzacji wykonywania poleceń powłoki. GNU Make to jeden konkretny program, który należy do rodziny Make. Marka pozostaje popularna wśród systemów operacyjnych typu Unix i POSIX, w tym pochodzących z jądra Linux, Mac OS X i BSD.

GNU Make jest szczególnie godne uwagi ze względu na dołączenie do Projektu GNU, który jest dołączony do popularnego systemu operacyjnego GNU / Linux. GNU Make ma również kompatybilne wersje działające na różnych wersjach Windows i Mac OS X. Jest to również bardzo stabilna wersja o znaczeniu historycznym, która pozostaje popularna. Z tych powodów GNU Make jest często nauczany obok C i C ++.

Podstawowe zasady

Aby skompilować z make, utwórz plik Makefile w katalogu projektu. Twój Makefile może być tak prosty jak:

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)

UWAGA: Upewnij się, że wcięcia są oznaczone tabulatorem, a nie czterema spacjami. W przeciwnym razie pojawi się błąd Makefile:10: *** missing separator. Stop.

Aby uruchomić to z wiersza polecenia, wykonaj następujące czynności:

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

$ ./app
Hello World!

$ make clean
$ ls
main.cpp  Makefile

Kompilacje przyrostowe

Kiedy zaczniesz mieć więcej plików, make staje się bardziej użyteczny. Co jeśli edytowałeś a.cpp, ale nie b.cpp ? Ponowna kompilacja b.cpp zajmie więcej czasu.

Dzięki następującej strukturze katalogów:

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

To byłby dobry 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

Ponownie obejrzyj zakładki. Ten nowy Makefile zapewnia, że rekompilujesz tylko zmienione pliki, minimalizując czas kompilacji.

Dokumentacja

Aby uzyskać więcej informacji na temat make, zobacz oficjalną dokumentację Free Software Foundation , dokumentację Stackoverflow i szczegółową odpowiedź dmckee na Stackoverflow .

Budowanie za pomocą SCons

Możesz zbudować wieloplatformowy kod C ++ „Hello World” , używając Scons - narzędzia do budowy oprogramowania w języku Python .

Najpierw utwórz plik o nazwie SConstruct (zwróć uwagę, że SConstruct szuka pliku o tej dokładnej nazwie). Na razie plik powinien znajdować się w katalogu tuż obok hello.cpp . Wpisz w nowym pliku linię

 Program('hello.cpp')

Teraz z terminalu uruchom scons . Powinieneś zobaczyć coś takiego

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

(chociaż szczegóły będą się różnić w zależności od systemu operacyjnego i zainstalowanego kompilatora).

Klasy Environment i Glob pomogą ci dalej konfigurować, co zbudować. Np. Plik SConstruct

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

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

buduje plik wykonywalny hello , używając wszystkich plików cpp w src . Jego CPPPATH to /usr/include/boost i określa on standard C ++ 11.

Ninja

Wprowadzenie

System kompilacji Ninja jest opisany na stronie internetowej projektu jako „system małych kompilacji z naciskiem na szybkość”. Ninja została zaprojektowana tak, aby generować pliki przez generatory plików systemu kompilacji, i stosuje podejście niskiego poziomu do budowania systemów, w przeciwieństwie do menedżerów systemów kompilacji wyższych poziomów, takich jak CMake lub Meson.

Ninja jest napisana głównie w C ++ i Python i została stworzona jako alternatywa dla systemu kompilacji SCons dla projektu Chromium.

NMAKE (Microsoft Program Maintenance Utility)

Wprowadzenie

NMAKE to narzędzie wiersza polecenia opracowane przez Microsoft do użytku głównie w połączeniu z Microsoft Visual Studio i / lub narzędziami wiersza polecenia Visual C ++.

NMAKE to system kompilacji, który należy do rodziny systemów kompilacji Make, ale ma pewne wyraźne cechy, które odbiegają od unikatowych programów Make, takich jak obsługa specyficznej dla Windows składni ścieżek plików (która sama różni się od ścieżek plików w stylu Uniksa).

Narzędzia automatyczne (GNU)

Wprowadzenie

Autotools to grupa programów, które tworzą system kompilacji GNU dla danego pakietu oprogramowania. Jest to zestaw narzędzi, które współpracują ze sobą w celu tworzenia różnych zasobów kompilacji, takich jak Makefile (do użycia z GNU Make). W ten sposób narzędzia automatyczne można uznać za de facto generator systemu kompilacji.

Niektóre znaczące programy Autotools obejmują:

• Autoconf
• Automake (nie mylić z make )

Ogólnie rzecz biorąc, Autotools ma generować skrypt kompatybilny z Uniksem i Makefile, aby umożliwić następującemu poleceniu zbudowanie (jak również zainstalowanie) większości pakietów (w prostym przypadku):

./configure && make && make install

Jako takie, Autotools ma również relacje z niektórymi menedżerami pakietów, szczególnie tymi, które są podłączone do systemów operacyjnych zgodnych ze standardem (-ami) POSIX.