C++
Construir sistemas

Introducción

Observaciones

Generando entorno de construcción con CMake

CMake genera entornos de compilación para casi cualquier compilador o IDE a partir de una sola definición de proyecto. Los siguientes ejemplos demostrarán cómo agregar un archivo CMake al código C ++ multiplataforma "Hello World" .

Los archivos CMake siempre se denominan "CMakeLists.txt" y ya deberían existir en el directorio raíz de cada proyecto (y posiblemente también en los subdirectorios). Un archivo básico de CMakeLists.txt tiene el siguiente aspecto:

cmake_minimum_required(VERSION 2.4)

project(HelloWorld)

add_executable(HelloWorld main.cpp)

Véalo en vivo en Coliru .

Este archivo le dice a CMake el nombre del proyecto, qué versión de archivo debe esperar e instrucciones para generar un ejecutable llamado "HelloWorld" que requiere main.cpp .

Genere un entorno de compilación para su compilador / IDE instalado desde la línea de comandos:

> cmake .

Construye la aplicación con:

> cmake --build .

Esto genera el entorno de compilación predeterminado para el sistema, según el sistema operativo y las herramientas instaladas. Mantenga el código fuente limpio de cualquier artefacto de construcción con el uso de compilaciones "fuera de la fuente":

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

CMake también puede abstraer los comandos básicos del shell de la plataforma del ejemplo anterior:

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

CMake incluye generadores para una serie de herramientas de construcción e IDE comunes. Para generar makefiles para nmake Visual Studio :

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

Compilando con GNU make

Introducción

GNU Make (styled make ) es un programa dedicado a la automatización de ejecutar comandos de shell. GNU Make es un programa específico que pertenece a la familia Make. Sigue siendo popular entre los sistemas operativos similares a Unix y POSIX, incluidos los derivados del kernel de Linux, Mac OS X y BSD.

GNU Make es especialmente notable por estar vinculado al Proyecto GNU, que está vinculado al popular sistema operativo GNU / Linux. GNU Make también tiene versiones compatibles que se ejecutan en varias versiones de Windows y Mac OS X. También es una versión muy estable con un significado histórico que sigue siendo popular. Es por estas razones que GNU Make se enseña a menudo junto con C y C ++.

Reglas básicas

Para compilar con make, cree un Makefile en el directorio de su proyecto. Su Makefile podría ser tan simple como:

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: asegúrese de que las sangrías estén con una pestaña, no con cuatro espacios. De lo contrario, obtendrá un error de Makefile:10: *** missing separator. Stop.

Para ejecutar esto desde la línea de comandos, haga lo siguiente:

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

$ ./app
Hello World!

$ make clean
$ ls
main.cpp  Makefile

Construcciones incrementales

Cuando empiezas a tener más archivos, make se vuelve más útil. ¿Qué pasa si editas a.cpp pero no b.cpp ? Recompilar b.cpp tomaría más tiempo.

Con la siguiente estructura de directorios:

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

Esto sería un buen 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

De nuevo mira las pestañas. Este nuevo Makefile garantiza que solo recompile archivos modificados, minimizando el tiempo de compilación.

Documentación

Para obtener más información sobre make, consulte la documentación oficial de Free Software Foundation , la documentación de stackoverflow y la elaborada respuesta de dmckee sobre stackoverflow .

Construyendo con scons

Puede crear el código C ++ multiplataforma "Hello World" , utilizando Scons , una herramienta de construcción de software en lenguaje Python .

Primero, cree un archivo llamado SConstruct (tenga en cuenta que SCons buscará un archivo con este nombre exacto de forma predeterminada). Por ahora, el archivo debe estar en un directorio a lo largo de su hello.cpp . Escribe en el nuevo archivo la línea.

 Program('hello.cpp')

Ahora, desde la terminal, ejecute scons . Deberías ver algo como

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

(aunque los detalles variarán dependiendo de su sistema operativo y compilador instalado).

Las clases Environment y Glob le ayudarán a configurar aún más qué construir. Por ejemplo, el archivo SConstruct

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

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

construye el ejecutable hello , usando todos los archivos cpp en src . Su CPPPATH es /usr/include/boost y especifica el estándar C ++ 11.

Ninja

Introducción

El sistema de construcción Ninja se describe en el sitio web del proyecto como "un sistema de construcción pequeña con un enfoque en la velocidad". Ninja está diseñado para generar sus archivos mediante generadores de archivos de sistema de compilación, y adopta un enfoque de bajo nivel para construir sistemas, en contraste con los administradores de sistemas de compilación de nivel superior como CMake o Meson.

Ninja está escrito principalmente en C ++ y Python, y fue creado como una alternativa al sistema de construcción SCons para el proyecto Chromium.

NMAKE (Utilidad de mantenimiento de programas de Microsoft)

Introducción

NMAKE es una utilidad de línea de comandos desarrollada por Microsoft para ser utilizada principalmente junto con Microsoft Visual Studio y / o las herramientas de línea de comandos de Visual C ++.

NMAKE es un sistema de compilación que forma parte de la familia Make de sistemas de compilación, pero tiene ciertas características distintas que divergen de los programas Make de Unix, como la sintaxis de rutas de archivos específicas de Windows (que a su vez difiere de las rutas de archivos de estilo Unix)

Autotools (GNU)

Introducción

Los Autotools son un grupo de programas que crean un sistema de compilación GNU para un paquete de software dado. Es un conjunto de herramientas que trabajan en conjunto para producir varios recursos de compilación, como un Makefile (para usar con GNU Make). Por lo tanto, Autotools puede considerarse un generador de sistema de construcción de facto.

Algunos programas notables de Autotools incluyen:

• Autoconf
• Automake (no debe confundirse con make )

En general, Autotools está destinado a generar el script compatible con Unix y Makefile para permitir que el siguiente comando genere (e instale) la mayoría de los paquetes (en el caso simple):

./configure && make && make install

Como tal, Autotools también tiene una relación con ciertos administradores de paquetes, especialmente aquellos que están conectados a sistemas operativos que cumplen con los Estándares POSIX.